inline Eigen::Matrix<fvar<T>,R,1>
rows_dot_self(const Eigen::Matrix<fvar<T>,R,C>& x) {
Eigen::Matrix<fvar<T>,R,1> ret(x.rows(),1);
for (size_type i = 0; i < x.rows(); i++) {
Eigen::Matrix<fvar<T>,1,C> crow = x.row(i);
ret(i,0) = dot_self(crow);
}
return ret;
}
inline fvar<T>
squared_distance(const Eigen::Matrix<double, R, C>& v1,
const Eigen::Matrix<fvar<T>, R, C>& v2) {
check_vector("squared_distance", "v1", v1);
check_vector("squared_distance", "v2", v2);
check_matching_sizes("squared_distance", "v1", v1, "v2", v2);
Eigen::Matrix<fvar<T>, R, C> v3 = subtract(v1, v2);
return dot_self(v3);
}
inline Eigen::Matrix<fvar<T>,1,C>
columns_dot_self(const Eigen::Matrix<fvar<T>,R,C>& x) {
Eigen::Matrix<fvar<T>,1,C> ret(1,x.cols());
for (size_type i = 0; i < x.cols(); i++) {
Eigen::Matrix<fvar<T>,R,1> ccol = x.col(i);
ret(0,i) = dot_self(ccol);
}
return ret;
}
inline fvar<T>
squared_distance(const Eigen::Matrix<fvar<T>, R1, C1>& v1,
const Eigen::Matrix<double, R2, C2>& v2) {
check_vector("squared_distance", "v1", v1);
check_vector("squared_distance", "v2", v2);
check_matching_sizes("squared_distance", "v1", v1, "v2", v2);
Eigen::Matrix<double, R1, C1> t_v2 = v2.transpose();
Eigen::Matrix<fvar<T>, R1, C1> v3 = subtract(v1, t_v2);
return dot_self(v3);
}
typename boost::math::tools::promote_args<T_y, T_covar, T_w>::type
multi_gp_cholesky_log(const Eigen::Matrix
<T_y, Eigen::Dynamic, Eigen::Dynamic>& y,
const Eigen::Matrix
<T_covar, Eigen::Dynamic, Eigen::Dynamic>& L,
const Eigen::Matrix<T_w, Eigen::Dynamic, 1>& w) {
static const char* function("multi_gp_cholesky_log");
typedef
typename boost::math::tools::promote_args<T_y, T_covar, T_w>::type T_lp;
T_lp lp(0.0);
check_size_match(function,
"Size of random variable (rows y)", y.rows(),
"Size of kernel scales (w)", w.size());
check_size_match(function,
"Size of random variable", y.cols(),
"rows of covariance parameter", L.rows());
check_finite(function, "Kernel scales", w);
check_positive(function, "Kernel scales", w);
check_finite(function, "Random variable", y);
if (y.rows() == 0)
return lp;
if (include_summand<propto>::value) {
lp += NEG_LOG_SQRT_TWO_PI * y.rows() * y.cols();
}
if (include_summand<propto, T_covar>::value) {
lp -= L.diagonal().array().log().sum() * y.rows();
}
if (include_summand<propto, T_w>::value) {
lp += 0.5 * y.cols() * sum(log(w));
}
if (include_summand<propto, T_y, T_w, T_covar>::value) {
T_lp sum_lp_vec(0.0);
for (int i = 0; i < y.rows(); i++) {
Eigen::Matrix<T_y, Eigen::Dynamic, 1> y_row(y.row(i));
Eigen::Matrix<typename boost::math::tools::promote_args
<T_y, T_covar>::type,
Eigen::Dynamic, 1>
half(mdivide_left_tri_low(L, y_row));
sum_lp_vec += w(i) * dot_self(half);
}
lp -= 0.5*sum_lp_vec;
}
return lp;
}
typename return_type<T_y, T_loc, T_covar>::type
multi_normal_cholesky_log(const T_y& y,
const T_loc& mu,
const T_covar& L) {
static const char* function("multi_normal_cholesky_log");
typedef typename scalar_type<T_covar>::type T_covar_elem;
typedef typename return_type<T_y, T_loc, T_covar>::type lp_type;
lp_type lp(0.0);
VectorViewMvt<const T_y> y_vec(y);
VectorViewMvt<const T_loc> mu_vec(mu);
size_t size_vec = max_size_mvt(y, mu);
int size_y = y_vec[0].size();
int size_mu = mu_vec[0].size();
if (size_vec > 1) {
int size_y_old = size_y;
int size_y_new;
for (size_t i = 1, size_ = length_mvt(y); i < size_; i++) {
int size_y_new = y_vec[i].size();
check_size_match(function,
"Size of one of the vectors of "
"the random variable", size_y_new,
"Size of another vector of the "
"random variable", size_y_old);
size_y_old = size_y_new;
}
int size_mu_old = size_mu;
int size_mu_new;
for (size_t i = 1, size_ = length_mvt(mu); i < size_; i++) {
int size_mu_new = mu_vec[i].size();
check_size_match(function,
"Size of one of the vectors of "
"the location variable", size_mu_new,
"Size of another vector of the "
"location variable", size_mu_old);
size_mu_old = size_mu_new;
}
(void) size_y_old;
(void) size_y_new;
(void) size_mu_old;
(void) size_mu_new;
}
check_size_match(function,
"Size of random variable", size_y,
"size of location parameter", size_mu);
check_size_match(function,
"Size of random variable", size_y,
"rows of covariance parameter", L.rows());
check_size_match(function,
"Size of random variable", size_y,
"columns of covariance parameter", L.cols());
for (size_t i = 0; i < size_vec; i++) {
check_finite(function, "Location parameter", mu_vec[i]);
check_not_nan(function, "Random variable", y_vec[i]);
}
if (size_y == 0)
return lp;
if (include_summand<propto>::value)
lp += NEG_LOG_SQRT_TWO_PI * size_y * size_vec;
if (include_summand<propto, T_covar_elem>::value)
lp -= L.diagonal().array().log().sum() * size_vec;
if (include_summand<propto, T_y, T_loc, T_covar_elem>::value) {
lp_type sum_lp_vec(0.0);
for (size_t i = 0; i < size_vec; i++) {
Eigen::Matrix<typename return_type<T_y, T_loc>::type,
Eigen::Dynamic, 1> y_minus_mu(size_y);
for (int j = 0; j < size_y; j++)
y_minus_mu(j) = y_vec[i](j)-mu_vec[i](j);
Eigen::Matrix<typename return_type<T_y, T_loc, T_covar>::type,
Eigen::Dynamic, 1>
half(mdivide_left_tri_low(L, y_minus_mu));
// FIXME: this code does not compile. revert after fixing subtract()
// Eigen::Matrix<typename
// boost::math::tools::promote_args<T_covar,
// typename value_type<T_loc>::type,
// typename value_type<T_y>::type>::type>::type,
// Eigen::Dynamic, 1>
// half(mdivide_left_tri_low(L, subtract(y, mu)));
sum_lp_vec += dot_self(half);
}
lp -= 0.5*sum_lp_vec;
}
return lp;
}
static void
basic_tests(void)
{
char string[] = "I am a string";
WCHAR wstring[] = {'I',' ','a','m',' ','a',' ','w','s','t','r','i','n','g', 0};
int f[5] = {1, 3, 0, -2, -4};
vector_t a = {1, 3, 7};
vector_t vec1 = {4, -2, 1}, vec2 = {-5, 2, 3}, *pvec2 = &vec2;
pvectors_t pvecs = {&vec1, &pvec2};
sp_inner_t spi = {42};
sp_t sp = {-13, &spi};
aligns_t aligns;
pints_t pints;
ptypes_t ptypes;
padded_t padded;
padded_t padded2[2];
bogus_t bogus;
int i1, i2, i3, *pi2, *pi3, **ppi3;
double u, v;
float s, t;
LONG q, r;
short h;
char c;
int x;
str_struct_t ss = {string};
wstr_struct_t ws = {wstring};
str_t str;
se_t se;
renum_t re;
ok(int_return() == INT_CODE, "RPC int_return\n");
ok(square(7) == 49, "RPC square\n");
ok(sum(23, -4) == 19, "RPC sum\n");
x = 0;
square_out(11, &x);
ok(x == 121, "RPC square_out\n");
x = 5;
square_ref(&x);
ok(x == 25, "RPC square_ref\n");
ok(str_length(string) == strlen(string), "RPC str_length\n");
ok(str_t_length(string) == strlen(string), "RPC str_length\n");
ok(dot_self(&a) == 59, "RPC dot_self\n");
ok(str_struct_len(&ss) == lstrlenA(string), "RPC str_struct_len\n");
ok(wstr_struct_len(&ws) == lstrlenW(wstring), "RPC str_struct_len\n");
v = 0.0;
u = square_half(3.0, &v);
ok(u == 9.0, "RPC square_half\n");
ok(v == 1.5, "RPC square_half\n");
t = 0.0f;
s = square_half_float(3.0f, &t);
ok(s == 9.0f, "RPC square_half_float\n");
ok(t == 1.5f, "RPC square_half_float\n");
r = 0;
q = square_half_long(3, &r);
ok(q == 9, "RPC square_half_long\n");
ok(r == 1, "RPC square_half_long\n");
i1 = 19;
i2 = -3;
i3 = -29;
pi2 = &i2;
pi3 = &i3;
ppi3 = &pi3;
pints.pi = &i1;
pints.ppi = &pi2;
pints.pppi = &ppi3;
ok(pints_sum(&pints) == -13, "RPC pints_sum\n");
c = 10;
h = 3;
q = 14;
s = -5.0f;
u = 11.0;
ptypes.pc = &c;
ptypes.ps = &h;
ptypes.pl = &q;
ptypes.pf = &s;
ptypes.pd = &u;
ok(ptypes_sum(&ptypes) == 33.0, "RPC ptypes_sum\n");
ok(dot_pvectors(&pvecs) == -21, "RPC dot_pvectors\n");
ok(dot_copy_vectors(vec1, vec2) == -21, "RPC dot_copy_vectors\n");
ok(sum_fixed_array(f) == -2, "RPC sum_fixed_array\n");
ok(sum_sp(&sp) == 29, "RPC sum_sp\n");
ok(enum_ord(E1) == 1, "RPC enum_ord\n");
ok(enum_ord(E2) == 2, "RPC enum_ord\n");
ok(enum_ord(E3) == 3, "RPC enum_ord\n");
ok(enum_ord(E4) == 4, "RPC enum_ord\n");
se.f = E2;
check_se2(&se);
memset(&aligns, 0, sizeof(aligns));
aligns.c = 3;
aligns.i = 4;
aligns.s = 5;
aligns.d = 6.0;
ok(sum_aligns(&aligns) == 18.0, "RPC sum_aligns\n");
padded.i = -3;
padded.c = 8;
ok(sum_padded(&padded) == 5, "RPC sum_padded\n");
padded2[0].i = -5;
padded2[0].c = 1;
padded2[1].i = 3;
padded2[1].c = 7;
ok(sum_padded2(padded2) == 6, "RPC sum_padded2\n");
padded2[0].i = -5;
padded2[0].c = 1;
padded2[1].i = 3;
padded2[1].c = 7;
ok(sum_padded_conf(padded2, 2) == 6, "RPC sum_padded_conf\n");
i1 = 14;
i2 = -7;
i3 = -4;
bogus.h.p1 = &i1;
bogus.p2 = &i2;
bogus.p3 = &i3;
bogus.c = 9;
ok(sum_bogus(&bogus) == 12, "RPC sum_bogus\n");
check_null(NULL);
str = get_filename();
ok(!strcmp(str, __FILE__), "get_filename() returned %s instead of %s\n", str, __FILE__);
midl_user_free(str);
x = echo_ranged_int(0);
ok(x == 0, "echo_ranged_int() returned %d instead of 0\n", x);
x = echo_ranged_int(100);
ok(x == 100, "echo_ranged_int() returned %d instead of 100\n", x);
if (!old_windows_version)
{
get_ranged_enum(&re);
ok(re == RE3, "get_ranged_enum() returned %d instead of RE3\n", re);
}
}