offset_multiplier_free.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_CONSTRAINT_OFFSET_MULTIPLIER_FREE_HPP
#define STAN_MATH_PRIM_CONSTRAINT_OFFSET_MULTIPLIER_FREE_HPP
 
#include <stan/math/prim/meta.hpp>
#include <stan/math/prim/err.hpp>
#include <stan/math/prim/constraint/identity_free.hpp>
#include <stan/math/prim/fun/to_ref.hpp>
#include <stan/math/prim/fun/eval.hpp>
#include <stan/math/prim/fun/value_of.hpp>
#include <cmath>
 
namespace stan {
namespace math {
 
template <typename T, typename M, typename S>
inline auto offset_multiplier_free(const T& y, const M& mu, const S& sigma) {
  auto&& mu_ref = to_ref(mu);
  auto&& sigma_ref = to_ref(sigma);
  if (is_matrix<T>::value && is_matrix<M>::value) {
    check_matching_dims("offset_multiplier_constrain", "y", y, "mu", mu);
  }
  if (is_matrix<T>::value && is_matrix<S>::value) {
    check_matching_dims("offset_multiplier_constrain", "y", y, "sigma", sigma);
  } else if (is_matrix<M>::value && is_matrix<S>::value) {
    check_matching_dims("offset_multiplier_constrain", "mu", mu, "sigma",
                        sigma);
  }
 
  check_finite("offset_multiplier_constrain", "offset", value_of(mu_ref));
  check_positive_finite("offset_multiplier_constrain", "multiplier",
                        value_of(sigma_ref));
  return stan::math::eval(divide(subtract(y, mu_ref), sigma_ref));
}
 
template <typename T, typename M, typename S,
          require_all_not_std_vector_t<M, S>* = nullptr>
inline auto offset_multiplier_free(const std::vector<T>& x, const M& mu,
                                   const S& sigma) {
  std::vector<plain_type_t<decltype(offset_multiplier_free(x[0], mu, sigma))>>
      ret;
  ret.reserve(x.size());
  const auto& mu_ref = to_ref(mu);
  const auto& sigma_ref = to_ref(sigma);
  for (size_t i = 0; i < x.size(); ++i) {
    ret.emplace_back(offset_multiplier_free(x[i], mu_ref, sigma_ref));
  }
  return ret;
}
 
template <typename T, typename M, typename S,
          require_not_std_vector_t<M>* = nullptr>
inline auto offset_multiplier_free(const std::vector<T>& x, const M& mu,
                                   const std::vector<S>& sigma) {
  check_matching_dims("offset_multiplier_free", "x", x, "sigma", sigma);
  std::vector<
      plain_type_t<decltype(offset_multiplier_free(x[0], mu, sigma[0]))>>
      ret;
  ret.reserve(x.size());
  const auto& mu_ref = to_ref(mu);
  for (size_t i = 0; i < x.size(); ++i) {
    ret.emplace_back(offset_multiplier_free(x[i], mu_ref, sigma[i]));
  }
  return ret;
}
 
template <typename T, typename M, typename S,
          require_not_std_vector_t<S>* = nullptr>
inline auto offset_multiplier_free(const std::vector<T>& x,
                                   const std::vector<M>& mu, const S& sigma) {
  check_matching_dims("offset_multiplier_free", "x", x, "mu", mu);
  std::vector<
      plain_type_t<decltype(offset_multiplier_free(x[0], mu[0], sigma))>>
      ret;
  ret.reserve(x.size());
  const auto& sigma_ref = to_ref(sigma);
  for (size_t i = 0; i < x.size(); ++i) {
    ret.emplace_back(offset_multiplier_free(x[i], mu[i], sigma_ref));
  }
  return ret;
}
 
template <typename T, typename M, typename S>
inline auto offset_multiplier_free(const std::vector<T>& x,
                                   const std::vector<M>& mu,
                                   const std::vector<S>& sigma) {
  check_matching_dims("offset_multiplier_free", "x", x, "mu", mu);
  check_matching_dims("offset_multiplier_free", "x", x, "sigma", sigma);
  std::vector<
      plain_type_t<decltype(offset_multiplier_free(x[0], mu[0], sigma[0]))>>
      ret;
  ret.reserve(x.size());
  for (size_t i = 0; i < x.size(); ++i) {
    ret.emplace_back(offset_multiplier_free(x[i], mu[i], sigma[i]));
  }
  return ret;
}
 
}  // namespace math
}  // namespace stan
#endif