lb_constrain.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_CONSTRAINT_LB_CONSTRAIN_HPP
#define STAN_MATH_PRIM_CONSTRAINT_LB_CONSTRAIN_HPP
 
#include <stan/math/prim/meta.hpp>
#include <stan/math/prim/err.hpp>
#include <stan/math/prim/fun/constants.hpp>
#include <stan/math/prim/constraint/identity_constrain.hpp>
#include <stan/math/prim/constraint/identity_free.hpp>
#include <stan/math/prim/fun/add.hpp>
#include <stan/math/prim/fun/exp.hpp>
#include <stan/math/prim/fun/eval.hpp>
#include <stan/math/prim/fun/sum.hpp>
#include <stan/math/prim/fun/value_of.hpp>
#include <cmath>
 
namespace stan {
namespace math {
 
template <typename T, typename L, require_all_stan_scalar_t<T, L>* = nullptr,
          require_all_not_st_var<T, L>* = nullptr>
inline auto lb_constrain(const T& x, const L& lb) {
  if (unlikely(value_of_rec(lb) == NEGATIVE_INFTY)) {
    return identity_constrain(x, lb);
  } else {
    return add(exp(x), lb);
  }
}
 
template <typename T, typename L, typename Lp,
          require_all_stan_scalar_t<T, L>* = nullptr,
          require_all_not_st_var<T, L>* = nullptr,
          require_convertible_t<return_type_t<T, L>, Lp>* = nullptr>
inline auto lb_constrain(const T& x, const L& lb, Lp& lp) {
  if (value_of_rec(lb) == NEGATIVE_INFTY) {
    return identity_constrain(x, lb);
  } else {
    lp += x;
    return add(exp(x), lb);
  }
}
 
template <typename T, typename L, require_eigen_t<T>* = nullptr,
          require_stan_scalar_t<L>* = nullptr,
          require_all_not_st_var<T, L>* = nullptr>
inline auto lb_constrain(T&& x, L&& lb) {
  return eval(x.unaryExpr([lb](auto&& x) { return lb_constrain(x, lb); }));
}
 
template <typename T, typename L, typename Lp, require_eigen_t<T>* = nullptr,
          require_stan_scalar_t<L>* = nullptr,
          require_all_not_st_var<T, L>* = nullptr,
          require_convertible_t<return_type_t<T, L>, Lp>* = nullptr>
 
inline auto lb_constrain(const T& x, const L& lb, Lp& lp) {
  return eval(
      x.unaryExpr([lb, &lp](auto&& xx) { return lb_constrain(xx, lb, lp); }));
}
 
template <typename T, typename L, require_all_eigen_t<T, L>* = nullptr,
          require_all_not_st_var<T, L>* = nullptr>
inline auto lb_constrain(T&& x, L&& lb) {
  check_matching_dims("lb_constrain", "x", x, "lb", lb);
  return eval(x.binaryExpr(
      lb, [](auto&& x, auto&& lb) { return lb_constrain(x, lb); }));
}
 
template <typename T, typename L, typename Lp,
          require_all_eigen_t<T, L>* = nullptr,
          require_all_not_st_var<T, L>* = nullptr,
          require_convertible_t<return_type_t<T, L>, Lp>* = nullptr>
inline auto lb_constrain(const T& x, const L& lb, Lp& lp) {
  check_matching_dims("lb_constrain", "x", x, "lb", lb);
  return eval(x.binaryExpr(
      lb, [&lp](auto&& xx, auto&& lbb) { return lb_constrain(xx, lbb, lp); }));
}
 
template <typename T, typename L, require_not_std_vector_t<L>* = nullptr>
inline auto lb_constrain(const std::vector<T>& x, const L& lb) {
  std::vector<plain_type_t<decltype(lb_constrain(x[0], lb))>> ret(x.size());
  for (size_t i = 0; i < x.size(); ++i) {
    ret[i] = lb_constrain(x[i], lb);
  }
  return ret;
}
 
template <typename T, typename L, typename Lp,
          require_not_std_vector_t<L>* = nullptr,
          require_convertible_t<return_type_t<T, L>, Lp>* = nullptr>
inline auto lb_constrain(const std::vector<T>& x, const L& lb, Lp& lp) {
  std::vector<plain_type_t<decltype(lb_constrain(x[0], lb))>> ret(x.size());
  for (size_t i = 0; i < x.size(); ++i) {
    ret[i] = lb_constrain(x[i], lb, lp);
  }
  return ret;
}
 
template <typename T, typename L>
inline auto lb_constrain(const std::vector<T>& x, const std::vector<L>& lb) {
  check_matching_dims("lb_constrain", "x", x, "lb", lb);
  std::vector<plain_type_t<decltype(lb_constrain(x[0], lb[0]))>> ret(x.size());
  for (size_t i = 0; i < x.size(); ++i) {
    ret[i] = lb_constrain(x[i], lb[i]);
  }
  return ret;
}
 
template <typename T, typename L, typename Lp,
          require_convertible_t<return_type_t<T, L>, Lp>* = nullptr>
inline auto lb_constrain(const std::vector<T>& x, const std::vector<L>& lb,
                         Lp& lp) {
  check_matching_dims("lb_constrain", "x", x, "lb", lb);
  std::vector<plain_type_t<decltype(lb_constrain(x[0], lb[0]))>> ret(x.size());
  for (size_t i = 0; i < x.size(); ++i) {
    ret[i] = lb_constrain(x[i], lb[i], lp);
  }
  return ret;
}
 
template <bool Jacobian, typename T, typename L, typename Lp,
          require_convertible_t<return_type_t<T, L>, Lp>* = nullptr>
inline auto lb_constrain(const T& x, const L& lb, Lp& lp) {
  if constexpr (Jacobian) {
    return lb_constrain(x, lb, lp);
  } else {
    return lb_constrain(x, lb);
  }
}
 
}  // namespace math
}  // namespace stan
 
#endif