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_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_FACTOR(group); DATA_MATRIX(covariates); // #obs x #par DATA_MATRIX(predCovariates); PARAMETER_MATRIX(beta); // #par x #group-1 Type nll; matrix<Type> probtmp = covariates * beta; // #obs x #group-1 matrix<Type> prob(probtmp.rows(),probtmp.cols()+1); // #obs x #group prob.block(0,0,probtmp.rows(),probtmp.cols()) = probtmp; prob.col(prob.cols()-1) = prob.col(0)*Type(0); prob = exp(prob.array()).matrix(); for(int i = 0; i < prob.rows(); ++i){ prob.row(i) = prob.row(i)/prob.row(i).sum(); } for(int i = 0; i < group.size(); i++){ nll -= log(prob(i,group(i))); } REPORT(prob); ADREPORT(prob); matrix<Type> probtmpP = predCovariates * beta; // #obs x #group-1 matrix<Type> probPred(probtmpP.rows(),probtmpP.cols()+1); // #obs x #group probPred.block(0,0,probtmpP.rows(),probtmpP.cols()) = probtmpP; probPred.col(probPred.cols()-1) = probPred.col(0)*Type(0); probPred = exp(prob.array()).matrix();//exp(probPred); for(int i = 0; i < probPred.rows(); ++i){ probPred.row(i) = probPred.row(i)/probPred.row(i).sum(); } REPORT(probPred); ADREPORT(probPred); return nll; }
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 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 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: 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_INTEGER(minAge); DATA_INTEGER(maxAge); DATA_INTEGER(minYear); DATA_INTEGER(maxYear); DATA_ARRAY(catchNo); DATA_ARRAY(stockMeanWeight); DATA_ARRAY(propMature); DATA_ARRAY(M); DATA_INTEGER(minAgeS); DATA_INTEGER(maxAgeS); DATA_INTEGER(minYearS); DATA_INTEGER(maxYearS); DATA_SCALAR(surveyTime); DATA_ARRAY(Q1); PARAMETER_VECTOR(logN1Y); PARAMETER_VECTOR(logN1A); PARAMETER_VECTOR(logFY); PARAMETER_VECTOR(logFA); PARAMETER_VECTOR(logVarLogCatch); PARAMETER_VECTOR(logQ); PARAMETER(logVarLogSurvey); int na=maxAge-minAge+1; int ny=maxYear-minYear+1; int nas=maxAgeS-minAgeS+1; int nys=maxYearS-minYearS+1; // setup F matrix<Type> F(ny,na); for(int y=0; y<ny; ++y){ for(int a=0; a<na; ++a){ F(y,a)=exp(logFY(y))*exp(logFA(a)); } } // setup logN matrix<Type> logN(ny,na); for(int a=0; a<na; ++a){ logN(0,a)=logN1Y(a); } for(int y=1; y<ny; ++y){ logN(y,0)=logN1A(y-1); for(int a=1; a<na; ++a){ logN(y,a)=logN(y-1,a-1)-F(y-1,a-1)-M(y-1,a-1); if(a==(na-1)){ logN(y,a)=log(exp(logN(y,a))+exp(logN(y,a-1)-F(y-1,a)-M(y-1,a))); } } } matrix<Type> predLogC(ny,na); for(int y=0; y<ny; ++y){ for(int a=0; a<na; ++a){ predLogC(y,a)=log(F(y,a))-log(F(y,a)+M(y,a))+log(Type(1.0)-exp(-F(y,a)-M(y,a)))+logN(y,a); } } Type ans=0; for(int y=0; y<ny; ++y){ for(int a=0; a<na; ++a){ if(a==0){ ans+= -dnorm(log(catchNo(y,a)),predLogC(y,a),exp(Type(0.5)*logVarLogCatch(0)),true); }else{ ans+= -dnorm(log(catchNo(y,a)),predLogC(y,a),exp(Type(0.5)*logVarLogCatch(1)),true); } } } matrix<Type> predLogS(nys,nas); for(int y=0; y<nys; ++y){ for(int a=0; a<nas; ++a){ int sa = a+(minAgeS-minAge); int sy = y+(minYearS-minYear); predLogS(y,a) = logQ(a)-(F(sy,sa)+M(sy,sa))*surveyTime+logN(sy,sa); ans += -dnorm(log(Q1(y,a)),predLogS(y,a),exp(Type(0.5)*logVarLogSurvey),true); } } vector<Type> ssb(ny); ssb.setZero(); for(int y=0; y<=ny; ++y){ for(int a=0; a<na; ++a){ std::cout<<y<<" "<<a<<" "<<"\n"; ssb(y)+=exp(logN(y,a))*stockMeanWeight(y,a)*propMature(y,a); } } ADREPORT(ssb); return ans; }