Type objective_function<Type>::operator() () { DATA_VECTOR(times); DATA_VECTOR(obs); PARAMETER(log_R0); PARAMETER(m); PARAMETER(log_theta); PARAMETER(log_sigma); Type theta=exp(log_theta); Type sigma=exp(log_sigma); Type R0=exp(log_R0); int n1=times.size(); int n2=2;//mean and variance vector<Type> Dt(n1-1); vector<Type> Ex(n1-1); vector<Type> Vx(n1-1); Type nll=0; m=0; Dt=diff(times); Ex=theta*(Type(1)-exp(-R0*Dt)) + obs.segment(0, n1-1)*exp(-R0*Dt); Vx=Type(0.5)*sigma*sigma*(Type(1)-exp(Type(-2)*R0*Dt))/R0; for(int i=0; i<n1-1; i++) { nll-= dnorm(obs[i+1], Ex[i], sqrt(Vx[i]), true); } return nll; }
Type objective_function<Type>::operator() () { DATA_MATRIX(obs); DATA_MATRIX(coord); DATA_VECTOR(covObs); DATA_INTEGER(p); DATA_VECTOR(h); PARAMETER(logObsSd); PARAMETER(logObsTSd); PARAMETER(logStatSd); PARAMETER_MATRIX(x); Type nll = 0.0; covafill<Type> cf(coord,covObs,h,p); // Contribution from states for(int i = 1; i < x.cols(); ++i) { nll -= dnorm(x(0,i), x(0,i-1), exp(logStatSd),true); nll -= dnorm(x(1,i), x(1,i-1), exp(logStatSd),true); } // contribution from observations for(int i = 0; i < obs.cols(); ++i) { nll -= dnorm(obs(0,i), x(0,i), exp(logObsSd),true); nll -= dnorm(obs(1,i), x(1,i), exp(logObsSd),true); vector<Type> tmp = x.col(i); Type val = evalFill((CppAD::vector<Type>)tmp, cf)[0]; nll -= dnorm(obs(2,i), val, exp(logObsTSd),true); } return nll; }
Type objective_function<Type>::operator() () { DATA_VECTOR(Y); DATA_VECTOR(x); PARAMETER(a); PARAMETER(b); PARAMETER(logSigma); parallel_accumulator<Type> nll(this); for(int i=0;i<x.size();i++)nll-=dnorm(Y[i],a+b*x[i],exp(logSigma),true); return nll; }
Type objective_function<Type>::operator() () { DATA_VECTOR(observed); PARAMETER_VECTOR(population); PARAMETER(log_process_error); PARAMETER(log_obs_error); Type process_error = exp(log_process_error); Type obs_error = exp(log_obs_error); int n_obs = observed.size(); // number of observations Type nll = 0; // negative log likelihood // likelihood for state transitions for(int y=1; y<n_obs; y++){ Type m = population[y-1]; nll -= dnorm(population(y), m, process_error, true); } // likelihood for observations for(int y=0; y<n_obs; y++){ nll -= dnorm(observed(y), population(y), obs_error, true); } ADREPORT(process_error); ADREPORT(obs_error); return nll; }
Type objective_function<Type>::operator() () { // Data DATA_VECTOR( y_i ); DATA_MATRIX( X_ij ); // Parameters PARAMETER_VECTOR( b_j ); PARAMETER_VECTOR( theta_z ); // Objective funcction Type zero_prob = 1 / (1 + exp(-theta_z(0))); Type logsd = exp(theta_z(1)); Type jnll = 0; int n_data = y_i.size(); // Linear predictor vector<Type> linpred_i( n_data ); linpred_i = X_ij * b_j; // Probability of data conditional on fixed effect values for( int i=0; i<n_data; i++){ if(y_i(i)==0) jnll -= log( zero_prob ); if(y_i(i)!=0) jnll -= log( 1-zero_prob ) + dlognorm( y_i(i), linpred_i(i), logsd, true ); } // Reporting REPORT( zero_prob ); REPORT( logsd ); REPORT( linpred_i ); return jnll; }
Type objective_function<Type>::operator() () { DATA_VECTOR(x); DATA_VECTOR(y); int n = y.size(); PARAMETER(b0); PARAMETER(b1); PARAMETER(logSigma); vector<Type> yfit(n); Type neglogL = 0.0; yfit = b0 + b1*x; neglogL = -sum(dnorm(y, yfit, exp(logSigma), true)); return neglogL; }
Type objective_function<Type>::operator() () { DATA_VECTOR(E); DATA_VECTOR(deaths); DATA_SPARSE_MATRIX(P); // precision matrix PARAMETER(alpha); PARAMETER(log_sigma2_V); PARAMETER_VECTOR(V); PARAMETER(log_sigma2_U); PARAMETER_VECTOR(W); int N = E.size(); vector<Type> log_deaths_pred(N); vector<Type> mu(N); Type nll = 0; Type tau_V = 1 / exp(log_sigma2_V); Type tau_U = 1 / exp(log_sigma2_U); nll -= dnorm(alpha, Type(0), Type(10), 1); nll -= dgamma(tau_V, Type(0.5), Type(2000), 1); nll -= dgamma(tau_U, Type(0.5), Type(2000), 1); nll -= dnorm(V, Type(0), exp(0.5 * log_sigma2_V), 1).sum(); vector<Type> tmp = P * W; nll -= -0.5 * (W * tmp).sum(); vector<Type> U = W * exp(0.5 * log_sigma2_U); nll -= dnorm(U.sum(), Type(0), Type(0.00001), 1); for (size_t i = 0; i < N; i++) log_deaths_pred(i) = log(E(i)) + alpha + V(i) + U(i); for (size_t i = 0; i < N; i++) nll -= dpois(deaths(i), exp(log_deaths_pred(i)), 1); for (size_t i = 0; i < N; i++) mu(i) = exp(alpha + V(i) + U(i)); vector<Type> deaths_pred = exp(log_deaths_pred); ADREPORT(U); ADREPORT(deaths_pred); ADREPORT(mu); return nll; }
Type objective_function<Type>::operator()() { DATA_FACTOR(Sex); DATA_VECTOR(Age); DATA_VECTOR(Length); int n = Length.size(); // These are the parameters (three are vectors; one is a scalar) PARAMETER_VECTOR(Linf); PARAMETER_VECTOR(Kappa); PARAMETER_VECTOR(t0); PARAMETER(LogSigma); Type Sigma = exp(LogSigma); vector<Type> LengthPred(n); // Provide the standard error of Sigma ADREPORT(Sigma); // Predictions and likelihoods for(int i=0;i<n;i++){ Type Temp = Kappa(Sex(i))*(Age(i)-t0(Sex(i))); LengthPred(i) = Linf(Sex(i))*(1.0-exp(-Temp)); } Type nll = -sum(dnorm(Length,LengthPred,Sigma,true)); // Prediction for sex 1 and age 10 Type Temp = Kappa(0)*(Type(10)-t0(0)); Type PredLen10 = Linf(0)*(1.0-exp(-Temp)); ADREPORT(PredLen10); // Predicted growth curve matrix<Type>LenPred(2,50); for (int Isex=0;Isex<2;Isex++) for (int Iage=1;Iage<=50;Iage++) { Temp = Kappa(Isex)*(Iage*1.0-t0(Isex)); LenPred(Isex,Iage-1) = Linf(Isex)*(1.0-exp(-Temp)); } REPORT(LenPred); return nll; }
Type objective_function<Type>::operator() () { DATA_VECTOR(times); DATA_VECTOR(obs); PARAMETER(log_R0); PARAMETER(log_a); PARAMETER(log_theta); PARAMETER(log_sigma); Type sigma=exp(log_sigma); Type theta=exp(log_theta); Type R0=exp(log_R0); Type a=exp(log_a)+Type(1e-4); int n1=times.size(); int n2=2;//mean and variance matrix<Type> xdist(n1,n2); //Ex and Vx Type m=(a-Type(1))*R0/times(n1-1); Type pen; xdist(0,0)=obs[0]; xdist(0,1)=Type(0); Type nll=0; Fun<Type> F; F.setpars(R0, m, theta, sigma); CppAD::vector<Type> xi(n2); xi[1]=Type(0); //Bottinger's code started variance at 0 for all lsoda calls Type ti; Type tf; for(int i=0; i<n1-1; i++) { xi[0] = Type(obs[i]); ti=times[i]; tf=times[i+1]; xdist.row(i+1) = vector<Type>(CppAD::Runge45(F, 1, ti, tf, xi)); xdist(i+1,1)=posfun(xdist(i+1,1), Type(1e-3), pen);//to keep the variance positive nll-= dnorm(obs[i+1], xdist(i+1,0), sqrt(xdist(i+1,1)), true); } nll+=pen; //penalty if the variance is near eps return nll; }
Type objective_function<Type>::operator() () { DATA_VECTOR(x); PARAMETER(mu); PARAMETER(logSigma); Type f; f = -sum(dnorm(x,mu,exp(logSigma), true)); return f; }
Type objective_function<Type>::operator() () { DATA_VECTOR(obs); DATA_FACTOR(group); PARAMETER_VECTOR(mu); PARAMETER_VECTOR(sd); Type res=0; for(int i=0;i<obs.size();i++){ res -= dnorm(obs[i],mu[group[i]],sd[group[i]],true); } return res; }
Type objective_function<Type>::operator() () { // Data DATA_INTEGER( n_data ); DATA_INTEGER( n_factors ); DATA_FACTOR( Factor ); DATA_VECTOR( Y ); DATA_VECTOR_INDICATOR(keep, Y); // Parameters PARAMETER( X0 ); PARAMETER( log_SD0 ); PARAMETER( log_SDZ ); PARAMETER_VECTOR( Z ); // Objective funcction Type jnll = 0; // Probability of data conditional on fixed and random effect values for( int i=0; i<n_data; i++){ jnll -= dnorm( Y(i), X0 + Z(Factor(i)), exp(log_SD0), true ); } // Probability of random coefficients for( int i=0; i<n_factors; i++){ jnll -= dnorm( Z(i), Type(0.0), exp(log_SDZ), true ); } // Reporting Type SDZ = exp(log_SDZ); Type SD0 = exp(log_SD0); ADREPORT( SDZ ); REPORT( SDZ ); ADREPORT( SD0 ); REPORT( SD0 ); ADREPORT( Z ); REPORT( Z ); ADREPORT( X0 ); REPORT( X0 ); // bias-correction testing Type MeanZ = Z.sum() / Z.size(); Type SampleVarZ = ( (Z-MeanZ) * (Z-MeanZ) ).sum(); Type SampleSDZ = pow( SampleVarZ + 1e-20, 0.5); REPORT( SampleVarZ ); REPORT( SampleSDZ ); ADREPORT( SampleVarZ ); ADREPORT( SampleSDZ ); return jnll; }
Type objective_function<Type>::operator() () { DATA_VECTOR(x); PARAMETER(mu); PARAMETER(logSigma); Type f; f = -sum(dnorm(x,mu,exp(logSigma), true)); f /= f / 0.0; std::cout << "f " << f << std::endl; return f; }
Type objective_function<Type>::operator() () { DATA_VECTOR(x); DATA_VECTOR(y); int n = y.size(); PARAMETER(b0); PARAMETER(b1); PARAMETER(logSigma); vector<Type> yfit(n); Type neglogL = 0.0; //Call triple function yfit = b0 + b1*x; neglogL = -sum(dnorm(y, yfit, exp(logSigma), true)); // JIM THORSON JUST ROCK'N TMB std::cout << b0<<" "<<b1<<"\n "; return neglogL; }
Type objective_function<Type>::operator() () { // data: DATA_MATRIX(age); DATA_VECTOR(len); DATA_SCALAR(CV_e); DATA_INTEGER(num_reads); // parameters: PARAMETER(r0); // reference value PARAMETER(b); // growth displacement PARAMETER(k); // growth rate PARAMETER(m); // slope of growth PARAMETER(CV_Lt); PARAMETER(gam_shape); PARAMETER(gam_scale); PARAMETER_VECTOR(age_re); // procedures: Type n = len.size(); Type nll = 0.0; // Initialize negative log-likelihood Type eps = 1e-5; CV_e = CV_e < 0.05 ? 0.05 : CV_e; for (int i = 0; i < n; i++) { Type x = age_re(i); if (!isNA(x) && isFinite(x)) { Type len_pred = pow(r0 + b * exp(k * x), m); Type sigma_e = CV_e * x + eps; Type sigma_Lt = CV_Lt * (len_pred + eps); nll -= dnorm(len(i), len_pred, sigma_Lt, true); nll -= dgamma(x + eps, gam_shape, gam_scale, true); for (int j = 0; j < num_reads; j++) { if (!isNA(age(j, i)) && isFinite(age(j, i)) && age(j, i) >= 0) { nll -= dnorm(age(j, i), x, sigma_e, true); } } } } return nll; }
Type objective_function<Type>::operator() () { DATA_VECTOR(height); DATA_VECTOR(times); DATA_IVECTOR(timeidx); DATA_IARRAY(trackinfo); DATA_VECTOR(weights); PARAMETER(logSigma); PARAMETER(logSigmaRW); PARAMETER(logitp); PARAMETER_VECTOR(u); int timeSteps=times.size(); int obsDim=height.size(); int noTracks=trackinfo.dim[0]; Type p=ilogit(logitp); Type ans=0; Type sdRW=exp(logSigmaRW); for(int i=1;i<timeSteps;i++) ans += -dnorm(u(i),u(i-1),sdRW*sqrt(times(i)-times(i-1)),true); Type sdObs=exp(logSigma); for(int t=0;t<noTracks;t++){ vector<Type> sub=height.segment(trackinfo(t,0),trackinfo(t,2)); vector<Type> subw=weights.segment(trackinfo(t,0),trackinfo(t,2)); for(int i=0;i<trackinfo(t,2);i++){ ans += nldens(sub(i),u(timeidx(trackinfo(t,0))-1),sdObs/sqrt(subw(i)),p); } } return ans; }
Type objective_function<Type>::operator() () { // data: DATA_MATRIX(age); DATA_VECTOR(len); DATA_SCALAR(CV_e); DATA_INTEGER(num_reads); // parameters: PARAMETER(a); // upper asymptote PARAMETER(b); // growth range PARAMETER(k); // growth rate PARAMETER(CV_Lt); PARAMETER(beta); PARAMETER_VECTOR(age_re); // procedures: Type n = len.size(); Type nll = 0.0; // Initialize negative log-likelihood Type eps = 1e-5; CV_e = CV_e < 0.05 ? 0.05 : CV_e; for (int i = 0; i < n; i++) { Type x = age_re(i); if (!isNA(x) && isFinite(x)) { Type len_pred = a / (1 + b * exp(-k * x)); Type sigma_e = CV_e * x + eps; Type sigma_Lt = CV_Lt * (len_pred + eps); nll -= dnorm(len(i), len_pred, sigma_Lt, true); nll -= dexp(x, beta, true); for (int j = 0; j < num_reads; j++) { if (!isNA(age(j, i)) && isFinite(age(j, i)) && age(j, i) >= 0) { nll -= dnorm(age(j, i), x, sigma_e, true); } } } } return nll; }
Type objective_function<Type>::operator() () { DATA_VECTOR(x); DATA_MATRIX(D); PARAMETER(phi); PARAMETER(kappa); matrix<Type> C(D); for(int i=0; i<C.rows(); i++) for(int j=0; j<C.cols(); j++) C(i,j) = matern(D(i,j), phi, kappa); Type nll = density::MVNORM_t<Type>(C)(x); return nll; }
Type objective_function<Type>::operator() () { DATA_VECTOR(y); PARAMETER(phi); PARAMETER(shape1); PARAMETER(shape2); PARAMETER(sd); PARAMETER_VECTOR(u); Type res = 0; res += density::AR1(phi)(u); vector<Type> unif = pnorm(u, Type(0), Type(1)); vector<Type> x = qbeta(unif, shape1, shape2); res -= dnorm(y, x, sd, true).sum(); return res; }
Type objective_function<Type>::operator() () { // Data DATA_INTEGER( n_y ); DATA_INTEGER( n_s ); DATA_IVECTOR( s_i ); DATA_VECTOR( y_i ); // Parameters PARAMETER( x0 ); //PARAMETER( log_sdz ); //variability in site effect //PARAMETER_VECTOR( z_s ); //site effect // Objective funcction Type jnll = 0; // Probability of data conditional on fixed and random effect values vector<Type> ypred_i(n_y); for( int i=0; i<n_y; i++){ ypred_i(i) = exp( x0 );//+ z_s(s_i(i)) ); jnll -= dpois( y_i(i), ypred_i(i), true ); } // Probability of random coefficients //for( int s=0; s<n_s; s++){ // jnll -= dnorm( z_s(s), Type(0.0), exp(log_sdz), true ); //} // Reporting //Type sdz = exp(log_sdz); //REPORT( sdz ); //REPORT( z_s ); REPORT( x0 ); //ADREPORT( sdz ); //ADREPORT( z_s ); ADREPORT( x0 ); return jnll; }
Type objective_function<Type>::operator()() { /* Data section */ DATA_VECTOR(Y); // Counted abundance DATA_VECTOR_INDICATOR(keep, Y); // For one-step predictions /* Parameter section */ PARAMETER_VECTOR(X); // Latent states. As last as long as Y; // extra elements are not used PARAMETER(logr); // Growth rate PARAMETER(logtheta); // With theta=1, the Ricker model PARAMETER(logK); // Carrying capacity PARAMETER(logQ); // Process noise PARAMETER(logS); // Sample size controlling measurement noise /* Procedure section */ Type r = exp(logr); Type theta = exp(logtheta); Type K = exp(logK); Type Q = exp(logQ); Type S = exp(logS); int timeSteps = Y.size(); Type nll = 0; // Contributions from state transitions for (int i = 1; i < timeSteps; i++) { Type m = X[i - 1] + r * (1.0 - pow(exp(X[i - 1]) / K, theta)); nll -= dnorm(X[i], m, sqrt(Q), true); } // Contributions from observations for (int i = 0; i < timeSteps; i++) { nll -= keep(i) * dpois(Y[i], S * exp(X[i]), true); // keep(i) for one-step predictions } return nll; }
Type objective_function<Type>::operator() () { DATA_VECTOR (a); DATA_ARRAY (b); DATA_MATRIX (c); DATA_SPARSE_MATRIX (d); PARAMETER (p); REPORT(a); REPORT(b); REPORT(c); REPORT(d); REPORT(p); //// Vector of anything: vector<matrix<Type> > voa(2); voa[0] = c; voa[1] = c; REPORT(voa); return 0; }
Type objective_function<Type>::operator() () { // Data DATA_VECTOR( y_i ); //capital letters - macro - Kasper built into C++ code // Parameters PARAMETER( mean ); PARAMETER( log_sd ); // Objective funcction Type sd = exp(log_sd); Type jnll = 0; int n_data = y_i.size(); // Probability of data conditional on fixed effect values for( int i=0; i<n_data; i++){ jnll -= dnorm( y_i(i), mean, sd, true ); } // Reporting return jnll; }
Type objective_function<Type>::operator() () { // data: DATA_MATRIX(x_ij); DATA_VECTOR(y_i); DATA_IVECTOR(k_i); // vector of IDs DATA_INTEGER(n_k); // number of IDs // parameters: PARAMETER_VECTOR(b_j) PARAMETER_VECTOR(sigma_j); PARAMETER(log_b0_sigma); PARAMETER_VECTOR(b0_k); int n_data = y_i.size(); // get number of data points to loop over // Linear predictor vector<Type> linear_predictor_i(n_data); vector<Type> linear_predictor_sigma_i(n_data); linear_predictor_i = x_ij*b_j; linear_predictor_sigma_i = sqrt(exp(x_ij*sigma_j)); Type nll = 0.0; // initialize negative log likelihood for(int i = 0; i < n_data; i++){ nll -= dnorm(y_i(i), b0_k(k_i(i)) + linear_predictor_i(i) , linear_predictor_sigma_i(i), true); } for(int k = 0; k < n_k; k++){ nll -= dnorm(b0_k(k), Type(0.0), exp(log_b0_sigma), true); } REPORT( b0_k ); REPORT(b_j ); ADREPORT( b0_k ); ADREPORT( b_j ); return nll; }
Type objective_function<Type>::operator()() { DATA_VECTOR(y); // Observations DATA_VECTOR_INDICATOR(keep, y); // For one-step predictions DATA_SCALAR(huge); PARAMETER_VECTOR(x); PARAMETER(mu); PARAMETER(logsigma); PARAMETER(logs); // Initial condition Type nll = -dnorm(x(0), Type(0), huge, true); // Increments for (int i = 1; i < x.size(); ++i) nll -= dnorm(x(i), x(i - 1) + mu, exp(logsigma), true); // Observations for (int i = 0; i < y.size(); ++i) nll -= keep(i) * dnorm(y(i), x(i), exp(logs), true); return nll; }
Type objective_function<Type>::operator() () { DATA_VECTOR(y); DATA_MATRIX(X) DATA_MATRIX(dd) PARAMETER_VECTOR(b); PARAMETER(a); PARAMETER(log_sigma); int n = dd.rows(); // Construct joint negative log-likelihood joint_nll<Type> jnll(y, X, dd, b, a, log_sigma); // Random effect initial guess vector<Type> u(n); u.setZero(); // Calculate Laplace approx (updates u) DATA_INTEGER(niter); Type res = laplace(jnll, u, niter); ADREPORT(u) return res; }
Type objective_function<Type>::operator() () { // data: DATA_MATRIX(x_ij); // fixed effect model matrix DATA_MATRIX(x_sigma_ij); // fixed effect model matrix DATA_VECTOR(y_i); // response vector DATA_IVECTOR(pholder_i); // vector of IDs for strategy DATA_IVECTOR(strategy_i); // vector of IDs for permit holder DATA_INTEGER(n_pholder); // number of IDs for pholder DATA_INTEGER(n_strategy); // number of IDs for strategy DATA_INTEGER(diversity_column); // fixed effect column position of diversity DATA_VECTOR(b1_cov_re_i); // predictor data for random slope DATA_VECTOR(b2_cov_re_i); // predictor data for random slope /* DATA_VECTOR(b3_cov_re_i); // predictor data for random slope */ DATA_VECTOR(g1_cov_re_i); // predictor data for random slope DATA_IVECTOR(spec_div_all_1); // indicator for if there is variability in diversity // parameters: PARAMETER_VECTOR(b_j); PARAMETER_VECTOR(sigma_j); PARAMETER(log_b0_pholder_tau); // PARAMETER(log_b1_pholder_tau); PARAMETER(log_b0_strategy_tau); PARAMETER(log_b1_strategy_tau); PARAMETER(log_b2_strategy_tau); /* PARAMETER(log_b3_strategy_tau); */ PARAMETER_VECTOR(b0_pholder); // PARAMETER_VECTOR(b1_pholder); PARAMETER_VECTOR(b0_strategy); PARAMETER_VECTOR(b1_strategy); PARAMETER_VECTOR(b2_strategy); /* PARAMETER_VECTOR(b3_strategy); */ //PARAMETER(log_g0_pholder_tau); PARAMETER(log_g0_strategy_tau); PARAMETER(log_g1_strategy_tau); // PARAMETER_VECTOR(g0_pholder); PARAMETER_VECTOR(g0_strategy); PARAMETER_VECTOR(g1_strategy); int n_data = y_i.size(); // Linear predictor vector<Type> linear_predictor_i(n_data); vector<Type> linear_predictor_sigma_i(n_data); vector<Type> eta(n_data); vector<Type> eta_sigma(n_data); linear_predictor_i = x_ij*b_j; linear_predictor_sigma_i = x_sigma_ij*sigma_j; /* // set slope deviations that we can't estimate to 0: */ /* for(int i = 0; i < n_data; i++){ */ /* if(spec_div_all_1(strategy_i(i)) == 1) { */ /* b1_strategy(strategy_i(i)) = 0; */ /* g1_strategy(strategy_i(i)) = 0; */ /* } */ /* } */ Type nll = 0.0; // initialize negative log likelihood for(int i = 0; i < n_data; i++){ eta(i) = b0_pholder(pholder_i(i)) + // b1_pholder(pholder_i(i)) * b1_cov_re_i(i) + b0_strategy(strategy_i(i)) + b1_strategy(strategy_i(i)) * b1_cov_re_i(i) + b2_strategy(strategy_i(i)) * b2_cov_re_i(i) + /* b3_strategy(strategy_i(i)) * b3_cov_re_i(i) + */ linear_predictor_i(i); eta_sigma(i) = sqrt(exp( // g0_pholder(pholder_i(i)) + g0_strategy(strategy_i(i)) + g1_strategy(strategy_i(i)) * g1_cov_re_i(i) + linear_predictor_sigma_i(i))); nll -= dnorm(y_i(i), eta(i), eta_sigma(i), true); } for(int k = 0; k < n_pholder; k++){ nll -= dnorm(b0_pholder(k), Type(0.0), exp(log_b0_pholder_tau), true); // nll -= dnorm(g0_pholder(k), Type(0.0), exp(log_g0_pholder_tau), true); // nll -= dnorm(b1_pholder(k), Type(0.0), exp(log_b1_pholder_tau), true); } for(int k = 0; k < n_strategy; k++){ nll -= dnorm(b0_strategy(k), Type(0.0), exp(log_b0_strategy_tau), true); nll -= dnorm(g0_strategy(k), Type(0.0), exp(log_g0_strategy_tau), true); // only include these species diversity slope deviations // if there was sufficient variation in species diversity // to estimate them: if(spec_div_all_1(k) == 0) { nll -= dnorm(b1_strategy(k), Type(0.0), exp(log_b1_strategy_tau), true); nll -= dnorm(g1_strategy(k), Type(0.0), exp(log_g1_strategy_tau), true); } nll -= dnorm(b2_strategy(k), Type(0.0), exp(log_b2_strategy_tau), true); /* nll -= dnorm(b3_strategy(k), Type(0.0), exp(log_b3_strategy_tau), true); */ } // Reporting /* Type b0_pholder_tau = exp(log_b0_pholder_tau); */ /* Type b0_strategy_tau = exp(log_b0_strategy_tau); */ // Type b1_tau = exp(log_b1_tau); /* Type g0_pholder_tau = exp(log_g0_pholder_tau); */ /* Type g0_strategy_tau = exp(log_g0_strategy_tau); */ // Type g1_tau = exp(log_g1_tau); vector<Type> combined_b1_strategy(n_strategy); vector<Type> combined_g1_strategy(n_strategy); for(int k = 0; k < n_strategy; k++){ // these are fixed-effect slopes + random-effect slopes combined_b1_strategy(k) = b_j(diversity_column) + b1_strategy(k); combined_g1_strategy(k) = sigma_j(diversity_column) + g1_strategy(k); } /* REPORT(b0_pholder); */ REPORT(b0_strategy); REPORT(eta); REPORT(b1_strategy); REPORT(b_j); /* REPORT(g0_pholder); */ REPORT(g0_strategy); REPORT(g1_strategy); /* REPORT(b0_tau); */ // REPORT(b1_tau); /* REPORT(g0_tau); */ // REPORT(g1_tau); REPORT(combined_b1_strategy); REPORT(combined_g1_strategy); // /* ADREPORT(b0_pholder); */ // ADREPORT(b0_strategy); // ADREPORT(b1_strategy); // ADREPORT(b_j); // /* ADREPORT(g0_pholder); */ // ADREPORT(g0_strategy); // ADREPORT(g1_strategy); // /* ADREPORT(b0_tau); */ // ADREPORT(b1_tau); // /* ADREPORT(g0_tau); */ // ADREPORT(g1_tau); ADREPORT(combined_b1_strategy); ADREPORT(combined_g1_strategy); return nll; }
Type objective_function<Type>::operator() () { // Data DATA_INTEGER( like ); // define likelihood type, 1==delta lognormal, 2==delta gamma DATA_VECTOR( y_i ); // observations DATA_MATRIX( X_ij ); // covariate design matrix DATA_VECTOR( include ); //0== include in NLL, 1== exclude from NLL // Parameters PARAMETER_VECTOR( b_j ); // betas to generate expected values PARAMETER_VECTOR( theta_z ); // variances // Transformations Type zero_prob = 1 / (1 + exp(-theta_z(0))); Type sd = exp(theta_z(1)); //standard deviation (lognormal), scale parameter theta (gamma) int n_data = y_i.size(); Type jnll = 0; Type pred_jnll = 0; vector<Type> jnll_i(n_data); // linear predictor vector<Type> logpred_i( n_data ); logpred_i = X_ij * b_j; // Delta lognormal if(like==1){ for( int i=0; i<n_data; i++){ if(y_i(i)==0) jnll_i(i) -= log( zero_prob ); if(y_i(i)!=0) jnll_i(i) -= log( 1-zero_prob ) + dlognorm( y_i(i), logpred_i(i), sd, true ); // Running counter if( include(i)==0 ) jnll += jnll_i(i); if( include(i)==1 ) pred_jnll += jnll_i(i); } } // Delta gamma if(like==2){ for(int i=0; i<n_data; i++){ if(y_i(i)==0) jnll_i(i) -= log( zero_prob ); if(y_i(i)!=0) jnll_i(i) -= log( 1-zero_prob ) + dgamma( y_i(i), pow(sd,-2), exp(logpred_i(i))*pow(sd,2), true ); // Running counter if( include(i)==0 ) jnll += jnll_i(i); if( include(i)==1 ) pred_jnll += jnll_i(i); } } // Reporting REPORT( zero_prob ); REPORT( sd ); REPORT( logpred_i ); REPORT( b_j ); REPORT( pred_jnll ); REPORT( jnll_i ); return jnll; }
Type objective_function<Type>::operator() () { // data: DATA_MATRIX(x_ij); DATA_VECTOR(y_i); DATA_IVECTOR(k_i); // vector of IDs DATA_INTEGER(n_k); // number of IDs DATA_INTEGER(n_j); // number of IDs DATA_VECTOR(b1_cov_re_i); // predictor data for random slope DATA_VECTOR(sigma1_cov_re_i); // predictor data for random slope //DATA_VECTOR(sigma2_cov_re_i); // predictor data for random slope // parameters: PARAMETER_VECTOR(b_j) PARAMETER_VECTOR(sigma_j); PARAMETER(log_b0_sigma); PARAMETER_VECTOR(b0_k); PARAMETER(log_b1_sigma); PARAMETER_VECTOR(b1_k); PARAMETER(log_sigma0_sigma); PARAMETER(log_sigma1_sigma); PARAMETER_VECTOR(sigma0_k); PARAMETER_VECTOR(sigma1_k); int n_data = y_i.size(); // get number of data points to loop over // Linear predictor vector<Type> linear_predictor_i(n_data); vector<Type> linear_predictor_sigma_i(n_data); linear_predictor_i = x_ij*b_j; linear_predictor_sigma_i = x_ij*sigma_j; Type nll = 0.0; // initialize negative log likelihood for(int i = 0; i < n_data; i++){ nll -= dnorm( y_i(i), b0_k(k_i(i)) + b1_k(k_i(i)) * b1_cov_re_i(i) + linear_predictor_i(i), sqrt(exp( sigma0_k(k_i(i)) + sigma1_k(k_i(i)) * sigma1_cov_re_i(i) + linear_predictor_sigma_i(i))), true); } for(int k = 0; k < n_k; k++){ nll -= dnorm(b0_k(k), Type(0.0), exp(log_b0_sigma), true); nll -= dnorm(b1_k(k), Type(0.0), exp(log_b1_sigma), true); nll -= dnorm(sigma0_k(k), Type(0.0), exp(log_sigma0_sigma), true); nll -= dnorm(sigma1_k(k), Type(0.0), exp(log_sigma1_sigma), true); //nll -= dnorm(sigma2_k(k), Type(0.0), exp(log_sigma2_sigma), true); } // Reporting Type b0_sigma = exp(log_b0_sigma); Type b1_sigma = exp(log_b1_sigma); Type sigma0_sigma = exp(log_sigma0_sigma); Type sigma1_sigma = exp(log_sigma1_sigma); //Type sigma2_sigma = exp(log_sigma2_sigma); vector<Type> b1_b1_k(n_k); vector<Type> sigma1_sigma1_k(n_k); for(int k = 0; k < n_k; k++){ // these are fixed-effect slopes + random-effect slopes b1_b1_k(k) = b_j(n_j) + b1_k(k); sigma1_sigma1_k(k) = sigma_j(n_j) + sigma1_k(k); } REPORT( b0_k ); REPORT( b1_k ); REPORT( b_j ); REPORT( sigma0_k ); REPORT( sigma1_k ); //REPORT( sigma2_k ); REPORT(b0_sigma); REPORT(b1_sigma); REPORT(sigma0_sigma); REPORT(sigma1_sigma); //REPORT(sigma2_sigma); REPORT(b1_b1_k); REPORT(sigma1_sigma1_k); //ADREPORT( b0_k ); //ADREPORT( b1_k ); //ADREPORT( b_j ); //ADREPORT( sigma0_k ); //ADREPORT( sigma1_k ); //ADREPORT( sigma2_k ); //ADREPORT(b0_sigma); //ADREPORT(b1_sigma); //ADREPORT(sigma0_sigma); //ADREPORT(sigma1_sigma); //ADREPORT(sigma2_sigma); //ADREPORT(b1_b1_k); //ADREPORT(sigma1_sigma1_k); return nll; }
Type objective_function<Type>::operator() () { // Data objects DATA_VECTOR(v1); DATA_MATRIX(m1); DATA_ARRAY(a1); // Parameter objects PARAMETER(p) // Not used in this example // Obtaining dimensions of objects REPORT(a1.dim); vector<int> d2(2); d2(0) = m1.rows(); d2(1) = m1.cols(); REPORT(d2); int d3 = v1.size(); REPORT(d3); // Matrix multiplication versus elementwise multiplication (similar for addition, subtraction,...) matrix<Type> m1m1 = m1*m1; // Matrix multiplication of matrices REPORT(m1m1); array<Type> a1a1 = a1*a1; // Element-wise multiplication of arrays REPORT(a1a1); matrix<Type> m1m1_by_element = (m1.array()*m1.array()).matrix(); // Elementwise multiplication of matrices REPORT(m1m1_by_element); array<Type> a1a1_matrix_mult(2,2); a1a1_matrix_mult = (a1.matrix()*a1.matrix()).array(); // Matrix multiplication of arrays REPORT(a1a1_matrix_mult); // Matrix-vector multiplication REPORT(m1*v1); // matrix-vector product (linear algebra style) Type v1_norm2 = (v1*v1).sum(); // Inner product v1*v1 REPORT(v1_norm2); // Indexing objects m1(1,1); // Element (1,1) of matrix m1 m1.row(1); // 2nd row of matrix m1 m1.col(1); // 2nd col of matrix m1 a1(1,1); // Element (1,1) of array a1 a1.transpose().col(1); // 2nd row of array a1 a1.col(1); //2nd col of array a1 v1(1); // 2nd element of vector v1 // Subsetting matrices and vectors v1.head(1); // First element of v1 v1.tail(1); // Last element of v1 m1.block(0,0,1,1); // Block of m1 consisting of m1(1,1) // Subsetting arrays // See R help pages for "template", i.e. "help(template)" in R // Generic matrix operations that we must ensure compiles m1.transpose(); m1.diagonal(); m1.asDiagonal(); Type ans; return ans; }