cpplint

Author: andrjohns

stan/math/prim/fun/cholesky_factor_constrain.hpp

@@ -37,7 +37,6 @@ cholesky_factor_constrain(const T& x, int M, int N) {
                    "((N * (N + 1)) / 2 + (M - N) * N)",
                    ((N * (N + 1)) / 2 + (M - N) * N));
   Eigen::Matrix<T_scalar, Eigen::Dynamic, Eigen::Dynamic> y(M, N);
-  T_scalar zero(0);
   int pos = 0;
 
   const auto& x_ref = to_ref(x);

stan/math/prim/fun/gp_exponential_cov.hpp

@@ -282,7 +282,6 @@ gp_exponential_cov(const std::vector<Eigen::Matrix<T_x1, -1, 1>> &x1,
   }
 
   T_s sigma_sq = square(sigma);
-  T_l temp;
 
   std::vector<Eigen::Matrix<return_type_t<T_x1, T_l>, -1, 1>> x1_new
       = divide_columns(x1, length_scale);

stan/math/prim/fun/lb_free.hpp

@@ -82,7 +82,6 @@ inline auto lb_free(T&& y, L&& lb) {
  */
 template <typename T, typename L, require_not_std_vector_t<L>* = nullptr>
 inline auto lb_free(const std::vector<T> y, const L& lb) {
-  auto&& lb_ref = to_ref(lb);
   std::vector<decltype(lb_free(y[0], lb))> ret(y.size());
   std::transform(y.begin(), y.end(), ret.begin(),
                  [&lb](auto&& yy) { return lb_free(yy, lb); });

stan/math/prim/fun/stan_print.hpp

@@ -71,7 +71,6 @@ void stan_print(std::ostream* o, const T& x) {
 template <typename T, require_tuple_t<T>*>
 void stan_print(std::ostream* o, const T& x) {
   *o << '(';
-  constexpr auto tuple_size = std::tuple_size<std::decay_t<T>>::value;
   size_t i = 0;
   stan::math::for_each(
       [&i, o](auto&& elt) {

stan/math/prim/functor/hcubature.hpp

@@ -490,7 +490,9 @@ double hcubature(const F& integrand, const T_pars& pars, const int& dim,
     std::vector<double> mb(box.b);
     mb[box.kdiv] -= w;
 
-    double result_1, result_2, err_1, err_2, kdivide_1, kdivide_2;
+    double result_1, result_2, err_1, err_2;
+    double kdivide_1 = math::NOT_A_NUMBER;
+    double kdivide_2 = math::NOT_A_NUMBER;
 
     if (dim == 1) {
       std::tie(result_1, err_1)

stan/math/prim/functor/operands_and_partials.hpp

@@ -55,6 +55,7 @@ class ops_partials_edge;
  */
 template <typename ViewElt, typename Op>
 class ops_partials_edge<ViewElt, Op, require_st_arithmetic<Op>> {
+  public:
   using inner_op = std::conditional_t<is_eigen<value_type_t<Op>>::value,
                                       value_type_t<Op>, Op>;
   using partials_t = empty_broadcast_array<ViewElt, inner_op>;

stan/math/rev/core/precomputed_gradients.hpp

@@ -80,10 +80,10 @@ class precomputed_gradients_vari_template : public vari {
         size_(size),
         varis_(varis),
         gradients_(gradients),
-        container_operands_(index_apply<N_containers>([&, this](auto... Is) {
+        container_operands_(index_apply<N_containers>([&](auto... Is) {
           return std::make_tuple(to_arena(std::get<Is>(container_operands))...);
         })),
-        container_gradients_(index_apply<N_containers>([&, this](auto... Is) {
+        container_gradients_(index_apply<N_containers>([&](auto... Is) {
           return std::make_tuple(
               to_arena(std::get<Is>(container_gradients))...);
         })) {
@@ -123,10 +123,10 @@ class precomputed_gradients_vari_template : public vari {
             vars.size())),
         gradients_(ChainableStack::instance_->memalloc_.alloc_array<double>(
             vars.size())),
-        container_operands_(index_apply<N_containers>([&, this](auto... Is) {
+        container_operands_(index_apply<N_containers>([&](auto... Is) {
           return std::make_tuple(to_arena(std::get<Is>(container_operands))...);
         })),
-        container_gradients_(index_apply<N_containers>([&, this](auto... Is) {
+        container_gradients_(index_apply<N_containers>([&](auto... Is) {
           return std::make_tuple(
               to_arena(std::get<Is>(container_gradients))...);
         })) {

stan/math/rev/core/vari.hpp

@@ -848,7 +848,7 @@ class vari_value<T, require_eigen_sparse_base_t<T>> : public vari_base,
    */
   template <typename S, require_convertible_t<S&, T>* = nullptr>
   explicit vari_value(S&& x)
-      : adj_(x), val_(std::forward<S>(x)), chainable_alloc() {
+      : chainable_alloc(), adj_(x), val_(std::forward<S>(x)) {
     this->set_zero_adjoint();
     ChainableStack::instance_->var_stack_.push_back(this);
   }
@@ -871,7 +871,7 @@ class vari_value<T, require_eigen_sparse_base_t<T>> : public vari_base,
    */
   template <typename S, require_convertible_t<S&, T>* = nullptr>
   vari_value(S&& x, bool stacked)
-      : adj_(x), val_(std::forward<S>(x)), chainable_alloc() {
+      : chainable_alloc(), adj_(x), val_(std::forward<S>(x)) {
     this->set_zero_adjoint();
     if (stacked) {
       ChainableStack::instance_->var_stack_.push_back(this);

stan/math/rev/fun/inv_inc_beta.hpp

@@ -59,7 +59,7 @@ inline var inv_inc_beta(const T1& a, const T2& b, const T3& p) {
   double b_val = value_of(b);
   double p_val = value_of(p);
   double w = inv_inc_beta(a_val, b_val, p_val);
-  return make_callback_var(w, [a, b, p, a_val, b_val, p_val, w](auto& vi) {
+  return make_callback_var(w, [a, b, p, a_val, b_val, w](auto& vi) {
     double log_w = log(w);
     double log1m_w = log1m(w);
     double one_m_a = 1 - a_val;

stan/math/rev/functor/cvodes_integrator_adjoint.hpp

@@ -93,8 +93,8 @@ class cvodes_integrator_adjoint_vari : public vari_base {
     N_Vector nv_absolute_tolerance_forward_;
     N_Vector nv_absolute_tolerance_backward_;
     SUNMatrix A_forward_;
-    SUNLinearSolver LS_forward_;
     SUNMatrix A_backward_;
+    SUNLinearSolver LS_forward_;
     SUNLinearSolver LS_backward_;
     void* cvodes_mem_;
     std::tuple<T_Args...> local_args_tuple_;