diff --git a/scripts/hooks/pre-commit b/scripts/hooks/pre-commit index 2d34ae045d..c4bf716ccb 100755 --- a/scripts/hooks/pre-commit +++ b/scripts/hooks/pre-commit @@ -1,4 +1,5 @@ #!/bin/bash +set -e cd "$(git rev-parse --show-toplevel)" || exit dune runtest src test/unit && make format curl -X POST -F "jenkinsfile=/dev/null | tee /dev/tty | grep "Jenkinsfile successfully validated." -q diff --git a/src/frontend/Typechecker.ml b/src/frontend/Typechecker.ml index 4df9f45ede..cb0218b86b 100644 --- a/src/frontend/Typechecker.ml +++ b/src/frontend/Typechecker.ml @@ -449,12 +449,27 @@ let verify_fn_target_plus_equals cf loc id = else if in_lp_function cf || cf.current_block = Model then () else Semantic_error.target_plusequals_outside_model_or_logprob loc |> error -let verify_fn_jacobian_plus_equals cf loc id = +let verify_fn_jacobian_plus_equals cf loc tenv id args = if String.is_suffix id.name ~suffix:"_jacobian" - && (not !Fun_kind.jacobian_compat_mode) - && not (in_jacobian_function cf || cf.current_block = TParam) - then Semantic_error.jacobian_plusequals_not_allowed loc |> error + && not !Fun_kind.jacobian_compat_mode + then + if not (in_jacobian_function cf || cf.current_block = TParam) then + Semantic_error.jacobian_plusequals_not_allowed loc |> error + else if + not + (List.exists args ~f:(fun e -> + UnsizedType.is_autodifftype e.emeta.ad_level)) + then + let alt = + String.chop_suffix_exn ~suffix:"_jacobian" id.name ^ "_constrain" in + let message = + "Calling a _jacobian function without any parameter arguments still \ + applies the Jacobian adjustments, ensure this is intentional!" + ^ + if Env.mem tenv alt then " Consider using " ^ alt ^ " instead." else "" + in + warnings := (loc, message) :: !warnings (** Rng functions cannot be used in Tp or Model and only in function defs with the right suffix @@ -703,7 +718,7 @@ and check_funapp loc cf tenv ~is_cond_dist id (es : Ast.typed_expression list) = verify_identifier id; name_check loc id; verify_fn_target_plus_equals cf loc id; - verify_fn_jacobian_plus_equals cf loc id; + verify_fn_jacobian_plus_equals cf loc tenv id es; verify_fn_rng cf loc id; verify_unnormalized cf loc id; res @@ -950,7 +965,7 @@ let check_nr_fn_app loc cf tenv id es = let tes = List.map ~f:(check_expression cf tenv) es in verify_identifier id; verify_fn_target_plus_equals cf loc id; - verify_fn_jacobian_plus_equals cf loc id; + verify_fn_jacobian_plus_equals cf loc tenv id tes; verify_fn_rng cf loc id; check_nrfn loc tenv id tes diff --git a/src/stan_math_backend/Lower_expr.ml b/src/stan_math_backend/Lower_expr.ml index b88e2e0cac..165d73463f 100644 --- a/src/stan_math_backend/Lower_expr.ml +++ b/src/stan_math_backend/Lower_expr.ml @@ -19,7 +19,23 @@ let fn_renames = @ [ ("lmultiply", "stan::math::multiply_log") ; ("lchoose", "stan::math::binomial_coefficient_log") ; ("std_normal_qf", "stan::math::inv_Phi") - ; ("integrate_ode", "stan::math::integrate_ode_rk45") ] + ; ("integrate_ode", "stan::math::integrate_ode_rk45") + (* constraints -- originally internal functions, may be worth renaming now *) + ; ("cholesky_factor_corr_jacobian", "stan::math::cholesky_corr_constrain") + ; ("cholesky_factor_corr_constrain", "stan::math::cholesky_corr_constrain") + ; ("cholesky_factor_corr_unconstrain", "stan::math::cholesky_corr_free") + ; ("cholesky_factor_cov_jacobian", "stan::math::cholesky_factor_constrain") + ; ("cholesky_factor_cov_constrain", "stan::math::cholesky_factor_constrain") + ; ("cholesky_factor_cov_unconstrain", "stan::math::cholesky_factor_free") + ; ("lower_bound_jacobian", "stan::math::lb_constrain") + ; ("lower_bound_constrain", "stan::math::lb_constrain") + ; ("lower_bound_unconstrain", "stan::math::lb_free") + ; ("upper_bound_jacobian", "stan::math::ub_constrain") + ; ("upper_bound_constrain", "stan::math::ub_constrain") + ; ("upper_bound_unconstrain", "stan::math::ub_free") + ; ("lower_upper_bound_jacobian", "stan::math::lub_constrain") + ; ("lower_upper_bound_constrain", "stan::math::lub_constrain") + ; ("lower_upper_bound_unconstrain", "stan::math::lub_free") ] |> String.Map.of_alist_exn let constraint_to_string = function @@ -103,9 +119,11 @@ let promote_adtype = | _ -> accum) ~init:UnsizedType.DataOnly -let suffix_args = function +let suffix_args udf = function | Fun_kind.FnRng -> ["base_rng__"] - | FnTarget | FnJacobian -> ["lp__"; "lp_accum__"] + | FnTarget -> ["lp__"; "lp_accum__"] + | FnJacobian when udf -> ["lp__"; "lp_accum__"] + | FnJacobian -> ["lp__"] | FnPlain | FnLpdf _ | FnLpmf _ -> [] let rec stantype_prim = function @@ -118,7 +136,7 @@ let templates udf suffix = | Fun_kind.FnLpdf true | FnLpmf true -> [TemplateType "propto__"] | FnLpdf false | FnLpmf false -> [TemplateType "false"] | FnTarget when udf -> [TemplateType "propto__"] - | FnJacobian when udf -> [TemplateType "jacobian__"] + | FnJacobian -> [TemplateType "jacobian__"] | _ -> [] let deserializer = Var "in__" @@ -396,6 +414,12 @@ and lower_functionals fname suffix es mem_pattern = and lower_fun_app suffix fname es mem_pattern (ret_type : UnsizedType.returntype option) = let fname = Option.value (Map.find fn_renames fname) ~default:fname in + let fname = + (* Handle systematic renaming of math's constrain and free functions *) + match String.rsplit2 fname ~on:'_' with + | Some (f, "jacobian") -> f ^ "_constrain" + | Some (f, "unconstrain") -> f ^ "_free" + | _ -> fname in let special_options = [ Option.map ~f:lower_operator_app (Operator.of_string_opt fname) ; lower_misc_special_math_app fname mem_pattern ret_type @@ -406,12 +430,12 @@ and lower_fun_app suffix fname es mem_pattern | None -> let fname = stan_namespace_qualify fname in let templates = templates false suffix in - let extras = suffix_args suffix |> List.map ~f:Exprs.to_var in + let extras = suffix_args false suffix |> List.map ~f:Exprs.to_var in Exprs.templated_fun_call fname templates (lower_exprs es @ extras) and lower_user_defined_fun f suffix es = let extra_args = - suffix_args suffix @ ["pstream__"] |> List.map ~f:Exprs.to_var in + suffix_args true suffix @ ["pstream__"] |> List.map ~f:Exprs.to_var in Exprs.templated_fun_call f (templates true suffix) ((lower_exprs ~promote_reals:true) es @ extra_args) diff --git a/src/stan_math_signatures/Generate.ml b/src/stan_math_signatures/Generate.ml index 80146deb0c..355edaee29 100644 --- a/src/stan_math_signatures/Generate.ml +++ b/src/stan_math_signatures/Generate.ml @@ -550,6 +550,44 @@ let add_binary_vec_int_int name supports_soa = , supports_soa )) (List.range 1 8) +(* things like lower_bound require the second argument be a scalar or the same + - this is basically the general case above with the last nested loop removed +*) +let add_first_arg_vector_binary name supports_soa = + let vectors = [UnsizedType.UArray UReal; UVector; URowVector; UMatrix] in + add_unqualified (name, ReturnType UReal, [UReal; UReal], supports_soa); + List.iter + ~f:(fun i -> + List.iter + ~f:(fun j -> + let ty = bare_array_type (j, i) in + add_unqualified (name, ReturnType ty, [ty; ty], supports_soa); + add_unqualified (name, ReturnType ty, [ty; UReal], supports_soa)) + vectors) + (List.range 0 8) + +let add_first_arg_vector_ternary name supports_soa = + let vectors = [UnsizedType.UArray UReal; UVector; URowVector; UMatrix] in + add_unqualified (name, ReturnType UReal, [UReal; UReal; UReal], supports_soa); + List.iter + ~f:(fun i -> + List.iter + ~f:(fun j -> + let ty = bare_array_type (j, i) in + add_unqualified (name, ReturnType ty, [ty; ty; ty], supports_soa); + add_unqualified (name, ReturnType ty, [ty; ty; UReal], supports_soa); + add_unqualified (name, ReturnType ty, [ty; UReal; ty], supports_soa)) + vectors) + (List.range 0 8) + +(** For functions that accept and return (arrays of...) vectors*) +let add_nested_vector_unary name supports_soa = + List.iter + ~f:(fun i -> + let t = bare_array_type (UVector, i) in + add_unqualified (name, ReturnType t, [t], supports_soa)) + (List.range 0 8) + let add_ternary name supports_soa = add_unqualified (name, ReturnType UReal, [UReal; UReal; UReal], supports_soa) @@ -842,8 +880,35 @@ let () = , ReturnType UComplexRowVector , [UComplexRowVector; UComplex] , AoS ); + List.iter + ~f:(fun i -> + let m = bare_array_type (UMatrix, i) in + let v = bare_array_type (UVector, i) in + add_unqualified ("corr_matrix_constrain", ReturnType m, [v; UInt], SoA); + add_unqualified ("corr_matrix_unconstrain", ReturnType v, [m], AoS); + add_unqualified ("corr_matrix_jacobian", ReturnType m, [v; UInt], SoA); + add_unqualified ("cov_matrix_constrain", ReturnType m, [v; UInt], SoA); + add_unqualified ("cov_matrix_unconstrain", ReturnType v, [m], AoS); + add_unqualified ("cov_matrix_jacobian", ReturnType m, [v; UInt], SoA)) + (List.range 0 8); add_unqualified ("chol2inv", ReturnType UMatrix, [UMatrix], AoS); add_unqualified ("cholesky_decompose", ReturnType UMatrix, [UMatrix], SoA); + List.iter + ~f:(fun i -> + let m = bare_array_type (UMatrix, i) in + let v = bare_array_type (UVector, i) in + add_unqualified + ("cholesky_factor_corr_constrain", ReturnType m, [v; UInt], SoA); + add_unqualified + ("cholesky_factor_corr_unconstrain", ReturnType v, [m], AoS); + add_unqualified + ("cholesky_factor_corr_jacobian", ReturnType m, [v; UInt], SoA); + add_unqualified + ("cholesky_factor_cov_constrain", ReturnType m, [v; UInt; UInt], SoA); + add_unqualified ("cholesky_factor_cov_unconstrain", ReturnType v, [m], AoS); + add_unqualified + ("cholesky_factor_cov_jacobian", ReturnType m, [v; UInt; UInt], SoA)) + (List.range 0 8); add_binary_vec_int_int "choose" AoS; add_unqualified ("col", ReturnType UVector, [UMatrix; UInt], AoS); add_unqualified ("col", ReturnType UComplexVector, [UComplexMatrix; UInt], SoA); @@ -1542,6 +1607,12 @@ let () = add_unqualified ("logical_eq", ReturnType UInt, [UComplex; UComplex], SoA); add_unqualified ("logical_neq", ReturnType UInt, [UComplex; UReal], SoA); add_unqualified ("logical_neq", ReturnType UInt, [UComplex; UComplex], SoA); + add_first_arg_vector_binary "lower_bound_jacobian" SoA; + add_first_arg_vector_binary "lower_bound_constrain" SoA; + add_first_arg_vector_binary "lower_bound_unconstrain" AoS; + add_first_arg_vector_ternary "lower_upper_bound_jacobian" SoA; + add_first_arg_vector_ternary "lower_upper_bound_constrain" SoA; + add_first_arg_vector_ternary "lower_upper_bound_unconstrain" AoS; add_nullary "machine_precision"; add_qualified ( "map_rect" @@ -1834,6 +1905,9 @@ let () = ("num_elements", ReturnType UInt, [bare_array_type (t, i)], SoA)) bare_types) (List.range 1 10); + add_first_arg_vector_ternary "offset_multiplier_jacobian" SoA; + add_first_arg_vector_ternary "offset_multiplier_constrain" SoA; + add_first_arg_vector_ternary "offset_multiplier_unconstrain" AoS; add_unqualified ("one_hot_int_array", ReturnType (UArray UInt), [UInt; UInt], SoA); add_unqualified ("one_hot_array", ReturnType (UArray UReal), [UInt; UInt], SoA); @@ -1844,6 +1918,9 @@ let () = add_unqualified ("ones_array", ReturnType (UArray UReal), [UInt], SoA); add_unqualified ("ones_row_vector", ReturnType URowVector, [UInt], SoA); add_unqualified ("ones_vector", ReturnType UVector, [UInt], SoA); + add_nested_vector_unary "ordered_jacobian" SoA; + add_nested_vector_unary "ordered_constrain" SoA; + add_nested_vector_unary "ordered_unconstrain" AoS; add_unqualified ( "ordered_logistic_glm_lpmf" , ReturnType UReal @@ -1914,6 +1991,9 @@ let () = , SoA ); add_unqualified ("polar", ReturnType UComplex, [UReal; UReal], AoS); add_nullary "positive_infinity"; + add_nested_vector_unary "positive_ordered_jacobian" SoA; + add_nested_vector_unary "positive_ordered_constrain" SoA; + add_nested_vector_unary "positive_ordered_unconstrain" AoS; add_binary_vec "pow" AoS; add_binary_vec_complex_complex "pow" AoS; add_unqualified ("prod", ReturnType UInt, [UArray UInt], AoS); @@ -2133,6 +2213,9 @@ let () = , SoA )) (List.range 1 4)) bare_types; + add_nested_vector_unary "simplex_jacobian" SoA; + add_nested_vector_unary "simplex_constrain" SoA; + add_nested_vector_unary "simplex_unconstrain" AoS; add_unqualified ("sin", ReturnType UComplex, [UComplex], AoS); add_unqualified ("sinh", ReturnType UComplex, [UComplex], AoS); add_unqualified ("singular_values", ReturnType UVector, [UMatrix], SoA); @@ -2171,6 +2254,16 @@ let () = add_unqualified ("sort_indices_desc", ReturnType (UArray UInt), [UVector], AoS); add_unqualified ("sort_indices_desc", ReturnType (UArray UInt), [URowVector], AoS); + List.iter + ~f:(fun i -> + let t = bare_array_type (UMatrix, i) in + add_unqualified ("stochastic_column_jacobian", ReturnType t, [t], SoA); + add_unqualified ("stochastic_column_constrain", ReturnType t, [t], SoA); + add_unqualified ("stochastic_column_unconstrain", ReturnType t, [t], AoS); + add_unqualified ("stochastic_row_jacobian", ReturnType t, [t], SoA); + add_unqualified ("stochastic_row_constrain", ReturnType t, [t], SoA); + add_unqualified ("stochastic_row_unconstrain", ReturnType t, [t], AoS)) + (List.range 0 8); add_unqualified ("squared_distance", ReturnType UReal, [UReal; UReal], SoA); add_unqualified ("squared_distance", ReturnType UReal, [UVector; UVector], SoA); add_unqualified @@ -2231,6 +2324,9 @@ let () = add_unqualified ("sum", ReturnType UComplex, [UComplexVector], SoA); add_unqualified ("sum", ReturnType UComplex, [UComplexRowVector], SoA); add_unqualified ("sum", ReturnType UComplex, [UComplexMatrix], SoA); + add_nested_vector_unary "sum_to_zero_jacobian" SoA; + add_nested_vector_unary "sum_to_zero_constrain" SoA; + add_nested_vector_unary "sum_to_zero_unconstrain" AoS; (* TODO (future): SoA inside of tuples, update following signatures *) add_unqualified ("svd", ReturnType (UTuple [UMatrix; UVector; UMatrix]), [UMatrix], AoS); @@ -2420,6 +2516,12 @@ let () = ("transpose", ReturnType UComplexVector, [UComplexRowVector], SoA); add_unqualified ("transpose", ReturnType UComplexMatrix, [UComplexMatrix], SoA); add_unqualified ("uniform_simplex", ReturnType UVector, [UInt], SoA); + add_nested_vector_unary "unit_vector_jacobian" SoA; + add_nested_vector_unary "unit_vector_constrain" SoA; + add_nested_vector_unary "unit_vector_unconstrain" AoS; + add_first_arg_vector_binary "upper_bound_jacobian" SoA; + add_first_arg_vector_binary "upper_bound_constrain" SoA; + add_first_arg_vector_binary "upper_bound_unconstrain" AoS; add_unqualified ("variance", ReturnType UReal, [UArray UReal], SoA); add_unqualified ("variance", ReturnType UReal, [UVector], SoA); add_unqualified ("variance", ReturnType UReal, [URowVector], SoA); diff --git a/test/integration/bad/err-jacobian-plusequals-scope3.stan b/test/integration/bad/err-jacobian-plusequals-scope3.stan index 5edebbebe4..00e8074a94 100644 --- a/test/integration/bad/err-jacobian-plusequals-scope3.stan +++ b/test/integration/bad/err-jacobian-plusequals-scope3.stan @@ -1,5 +1,5 @@ functions { - real upper_bound_jacobian(real x, real ub) { + real my_upper_bound_jacobian(real x, real ub) { jacobian += x; return ub - exp(x); } @@ -11,5 +11,5 @@ parameters { } model { - real b = upper_bound_jacobian(b_raw, ub); + real b = my_upper_bound_jacobian(b_raw, ub); } diff --git a/test/integration/bad/err-jacobian-plusequals-scope5.stan b/test/integration/bad/err-jacobian-plusequals-scope5.stan new file mode 100644 index 0000000000..5ead05e241 --- /dev/null +++ b/test/integration/bad/err-jacobian-plusequals-scope5.stan @@ -0,0 +1,9 @@ + +parameters { + real b_raw; + real ub; +} + +model { + real b = upper_bound_jacobian(b_raw, ub); +} diff --git a/test/integration/bad/stanc.expected b/test/integration/bad/stanc.expected index 271afcd433..a7c9809b0a 100644 --- a/test/integration/bad/stanc.expected +++ b/test/integration/bad/stanc.expected @@ -1074,11 +1074,11 @@ Semantic error in 'err-jacobian-plusequals-scope2.stan', line 3, column 4 to col The jacobian adjustment can only be applied in the transformed parameters block or in functions ending with _jacobian [exit 1] $ ../../../../install/default/bin/stanc err-jacobian-plusequals-scope3.stan -Semantic error in 'err-jacobian-plusequals-scope3.stan', line 14, column 11 to column 42: +Semantic error in 'err-jacobian-plusequals-scope3.stan', line 14, column 11 to column 45: ------------------------------------------------- 12: 13: model { - 14: real b = upper_bound_jacobian(b_raw, ub); + 14: real b = my_upper_bound_jacobian(b_raw, ub); ^ 15: } ------------------------------------------------- @@ -1095,6 +1095,18 @@ Semantic error in 'err-jacobian-plusequals-scope4.stan', line 8, column 2 to col 9: } ------------------------------------------------- +The jacobian adjustment can only be applied in the transformed parameters block or in functions ending with _jacobian +[exit 1] + $ ../../../../install/default/bin/stanc err-jacobian-plusequals-scope5.stan +Semantic error in 'err-jacobian-plusequals-scope5.stan', line 8, column 11 to column 42: + ------------------------------------------------- + 6: + 7: model { + 8: real b = upper_bound_jacobian(b_raw, ub); + ^ + 9: } + ------------------------------------------------- + The jacobian adjustment can only be applied in the transformed parameters block or in functions ending with _jacobian [exit 1] $ ../../../../install/default/bin/stanc err-minus-types.stan diff --git a/test/integration/good/code-gen/builtin-constraint.stan b/test/integration/good/code-gen/builtin-constraint.stan new file mode 100644 index 0000000000..a58422126f --- /dev/null +++ b/test/integration/good/code-gen/builtin-constraint.stan @@ -0,0 +1,18 @@ +data { + int K; +} +parameters { + vector[K-1] beta_raw; +} +transformed parameters { + sum_to_zero_vector[K] beta = sum_to_zero_jacobian(beta_raw); +} +model { + beta ~ normal(0, inv(sqrt(1 - inv(K)))); +} +generated quantities { + vector[K-1] beta_recovered = sum_to_zero_unconstrain(beta); + if (max(abs(beta_recovered - beta_raw)) > 1e-10) { + fatal_error("beta_recovered does not match beta"); + } +} diff --git a/test/integration/good/code-gen/cpp.expected b/test/integration/good/code-gen/cpp.expected index fe6d330d45..e069621967 100644 --- a/test/integration/good/code-gen/cpp.expected +++ b/test/integration/good/code-gen/cpp.expected @@ -868,6 +868,515 @@ stan::math::profile_map& get_stan_profile_data() { return _8start_with_number_model_namespace::profiles__; } #endif +[exit 0] + $ ../../../../../install/default/bin/stanc --print-cpp builtin-constraint.stan +// Code generated by %%NAME%% %%VERSION%% +#include +namespace builtin_constraint_model_namespace { +using stan::model::model_base_crtp; +using namespace stan::math; +stan::math::profile_map profiles__; +static constexpr std::array locations_array__ = + {" (found before start of program)", + " (in 'builtin-constraint.stan', line 5, column 2 to column 23)", + " (in 'builtin-constraint.stan', line 8, column 2 to column 62)", + " (in 'builtin-constraint.stan', line 14, column 2 to column 61)", + " (in 'builtin-constraint.stan', line 16, column 4 to column 54)", + " (in 'builtin-constraint.stan', line 15, column 51 to line 17, column 3)", + " (in 'builtin-constraint.stan', line 15, column 2 to line 17, column 3)", + " (in 'builtin-constraint.stan', line 11, column 2 to column 42)", + " (in 'builtin-constraint.stan', line 2, column 2 to column 17)", + " (in 'builtin-constraint.stan', line 5, column 9 to column 12)", + " (in 'builtin-constraint.stan', line 8, column 21 to column 22)", + " (in 'builtin-constraint.stan', line 14, column 9 to column 12)"}; +class builtin_constraint_model final : public model_base_crtp { + private: + int K; + int beta_raw_1dim__; + int beta_recovered_1dim__; + public: + ~builtin_constraint_model() {} + builtin_constraint_model(stan::io::var_context& context__, unsigned int + random_seed__ = 0, std::ostream* + pstream__ = nullptr) : model_base_crtp(0) { + int current_statement__ = 0; + // suppress unused var warning + (void) current_statement__; + using local_scalar_t__ = double; + auto base_rng__ = stan::services::util::create_rng(random_seed__, 0); + // suppress unused var warning + (void) base_rng__; + static constexpr const char* function__ = + "builtin_constraint_model_namespace::builtin_constraint_model"; + // suppress unused var warning + (void) function__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + // suppress unused var warning + (void) DUMMY_VAR__; + try { + current_statement__ = 8; + context__.validate_dims("data initialization", "K", "int", + std::vector{}); + K = std::numeric_limits::min(); + current_statement__ = 8; + K = context__.vals_i("K")[(1 - 1)]; + current_statement__ = 8; + stan::math::check_greater_or_equal(function__, "K", K, 1); + current_statement__ = 9; + beta_raw_1dim__ = std::numeric_limits::min(); + current_statement__ = 9; + beta_raw_1dim__ = (K - 1); + current_statement__ = 9; + stan::math::validate_non_negative_index("beta_raw", "K - 1", + beta_raw_1dim__); + current_statement__ = 10; + stan::math::validate_non_negative_index("beta", "K", K); + current_statement__ = 11; + beta_recovered_1dim__ = std::numeric_limits::min(); + current_statement__ = 11; + beta_recovered_1dim__ = (K - 1); + current_statement__ = 11; + stan::math::validate_non_negative_index("beta_recovered", "K - 1", + beta_recovered_1dim__); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + } + num_params_r__ = beta_raw_1dim__; + } + inline std::string model_name() const final { + return "builtin_constraint_model"; + } + inline std::vector model_compile_info() const noexcept { + return std::vector{"stanc_version = %%NAME%%3 %%VERSION%%", + "stancflags = --print-cpp"}; + } + // Base log prob + template * = nullptr, + stan::require_vector_like_vt* = nullptr, + stan::require_not_st_var* = nullptr> + inline stan::scalar_type_t + log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream* + pstream__ = nullptr) const { + using T__ = stan::scalar_type_t; + using local_scalar_t__ = T__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + stan::io::deserializer in__(params_r__, params_i__); + int current_statement__ = 0; + // suppress unused var warning + (void) current_statement__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + // suppress unused var warning + (void) DUMMY_VAR__; + static constexpr const char* function__ = + "builtin_constraint_model_namespace::log_prob"; + // suppress unused var warning + (void) function__; + try { + current_statement__ = 1; + auto beta_raw = + in__.template read< + Eigen::Matrix>(beta_raw_1dim__); + Eigen::Matrix beta = + Eigen::Matrix::Constant(K, DUMMY_VAR__); + current_statement__ = 2; + stan::model::assign(beta, + stan::math::sum_to_zero_constrain(beta_raw, lp__), + "assigning variable beta"); + current_statement__ = 2; + stan::math::check_sum_to_zero(function__, "beta", beta); + { + current_statement__ = 7; + lp_accum__.add(stan::math::normal_lpdf(beta, 0, + stan::math::inv( + stan::math::sqrt((1 - stan::math::inv(K)))))); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } + // Reverse mode autodiff log prob + template * = nullptr, + stan::require_vector_like_vt* = nullptr, + stan::require_st_var* = nullptr> + inline stan::scalar_type_t + log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream* + pstream__ = nullptr) const { + using T__ = stan::scalar_type_t; + using local_scalar_t__ = T__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + stan::io::deserializer in__(params_r__, params_i__); + int current_statement__ = 0; + // suppress unused var warning + (void) current_statement__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + // suppress unused var warning + (void) DUMMY_VAR__; + static constexpr const char* function__ = + "builtin_constraint_model_namespace::log_prob"; + // suppress unused var warning + (void) function__; + try { + current_statement__ = 1; + auto beta_raw = + in__.template read< + Eigen::Matrix>(beta_raw_1dim__); + Eigen::Matrix beta = + Eigen::Matrix::Constant(K, DUMMY_VAR__); + current_statement__ = 2; + stan::model::assign(beta, + stan::math::sum_to_zero_constrain(beta_raw, lp__), + "assigning variable beta"); + current_statement__ = 2; + stan::math::check_sum_to_zero(function__, "beta", beta); + { + current_statement__ = 7; + lp_accum__.add(stan::math::normal_lpdf(beta, 0, + stan::math::inv( + stan::math::sqrt((1 - stan::math::inv(K)))))); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } + template * = nullptr, stan::require_vector_like_vt* = nullptr, stan::require_vector_vt* = nullptr> + inline void + write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__, + VecVar& vars__, const bool + emit_transformed_parameters__ = true, const bool + emit_generated_quantities__ = true, std::ostream* + pstream__ = nullptr) const { + using local_scalar_t__ = double; + stan::io::deserializer in__(params_r__, params_i__); + stan::io::serializer out__(vars__); + static constexpr bool propto__ = true; + // suppress unused var warning + (void) propto__; + double lp__ = 0.0; + // suppress unused var warning + (void) lp__; + int current_statement__ = 0; + // suppress unused var warning + (void) current_statement__; + stan::math::accumulator lp_accum__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + // suppress unused var warning + (void) DUMMY_VAR__; + constexpr bool jacobian__ = false; + // suppress unused var warning + (void) jacobian__; + static constexpr const char* function__ = + "builtin_constraint_model_namespace::write_array"; + // suppress unused var warning + (void) function__; + try { + current_statement__ = 1; + auto beta_raw = + in__.template read< + Eigen::Matrix>(beta_raw_1dim__); + Eigen::Matrix beta = + Eigen::Matrix::Constant(K, + std::numeric_limits::quiet_NaN()); + out__.write(beta_raw); + if (stan::math::logical_negation( + (stan::math::primitive_value(emit_transformed_parameters__) || + stan::math::primitive_value(emit_generated_quantities__)))) { + return ; + } + current_statement__ = 2; + stan::model::assign(beta, + stan::math::sum_to_zero_constrain(beta_raw, lp__), + "assigning variable beta"); + current_statement__ = 2; + stan::math::check_sum_to_zero(function__, "beta", beta); + if (emit_transformed_parameters__) { + out__.write(beta); + } + if (stan::math::logical_negation(emit_generated_quantities__)) { + return ; + } + Eigen::Matrix beta_recovered = + Eigen::Matrix::Constant(beta_recovered_1dim__, + std::numeric_limits::quiet_NaN()); + current_statement__ = 3; + stan::model::assign(beta_recovered, stan::math::sum_to_zero_free(beta), + "assigning variable beta_recovered"); + current_statement__ = 6; + if (stan::math::logical_gt( + stan::math::max( + stan::math::abs(stan::math::subtract(beta_recovered, beta_raw))), + 1e-10)) { + current_statement__ = 4; + { + std::stringstream errmsg_stream__; + stan::math::stan_print(&errmsg_stream__, + "beta_recovered does not match beta"); + throw std::runtime_error(errmsg_stream__.str()); + } + } + out__.write(beta_recovered); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + } + } + template * = nullptr, + stan::require_vector_like_vt* = nullptr> + inline void + unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__, + VecVar& vars__, std::ostream* pstream__ = nullptr) const { + using local_scalar_t__ = double; + stan::io::deserializer in__(params_r__, params_i__); + stan::io::serializer out__(vars__); + int current_statement__ = 0; + // suppress unused var warning + (void) current_statement__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + // suppress unused var warning + (void) DUMMY_VAR__; + try { + Eigen::Matrix beta_raw = + Eigen::Matrix::Constant(beta_raw_1dim__, + DUMMY_VAR__); + current_statement__ = 1; + stan::model::assign(beta_raw, + in__.read>(beta_raw_1dim__), + "assigning variable beta_raw"); + out__.write(beta_raw); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + } + } + template * = nullptr> + inline void + transform_inits_impl(const stan::io::var_context& context__, VecVar& + vars__, std::ostream* pstream__ = nullptr) const { + using local_scalar_t__ = double; + stan::io::serializer out__(vars__); + int current_statement__ = 0; + // suppress unused var warning + (void) current_statement__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + // suppress unused var warning + (void) DUMMY_VAR__; + try { + current_statement__ = 1; + context__.validate_dims("parameter initialization", "beta_raw", + "double", std::vector{static_cast(beta_raw_1dim__)}); + int pos__ = std::numeric_limits::min(); + pos__ = 1; + Eigen::Matrix beta_raw = + Eigen::Matrix::Constant(beta_raw_1dim__, + DUMMY_VAR__); + { + std::vector beta_raw_flat__; + current_statement__ = 1; + beta_raw_flat__ = context__.vals_r("beta_raw"); + pos__ = 1; + for (int sym1__ = 1; sym1__ <= beta_raw_1dim__; ++sym1__) { + stan::model::assign(beta_raw, beta_raw_flat__[(pos__ - 1)], + "assigning variable beta_raw", stan::model::index_uni(sym1__)); + pos__ = (pos__ + 1); + } + } + out__.write(beta_raw); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + } + } + inline void + get_param_names(std::vector& names__, const bool + emit_transformed_parameters__ = true, const bool + emit_generated_quantities__ = true) const { + names__ = std::vector{"beta_raw"}; + if (emit_transformed_parameters__) { + std::vector temp{"beta"}; + names__.reserve(names__.size() + temp.size()); + names__.insert(names__.end(), temp.begin(), temp.end()); + } + if (emit_generated_quantities__) { + std::vector temp{"beta_recovered"}; + names__.reserve(names__.size() + temp.size()); + names__.insert(names__.end(), temp.begin(), temp.end()); + } + } + inline void + get_dims(std::vector>& dimss__, const bool + emit_transformed_parameters__ = true, const bool + emit_generated_quantities__ = true) const { + dimss__ = std::vector>{std::vector{static_cast< + size_t>( + beta_raw_1dim__)}}; + if (emit_transformed_parameters__) { + std::vector> + temp{std::vector{static_cast(K)}}; + dimss__.reserve(dimss__.size() + temp.size()); + dimss__.insert(dimss__.end(), temp.begin(), temp.end()); + } + if (emit_generated_quantities__) { + std::vector> + temp{std::vector{static_cast(beta_recovered_1dim__)}}; + dimss__.reserve(dimss__.size() + temp.size()); + dimss__.insert(dimss__.end(), temp.begin(), temp.end()); + } + } + inline void + constrained_param_names(std::vector& param_names__, bool + emit_transformed_parameters__ = true, bool + emit_generated_quantities__ = true) const final { + for (int sym1__ = 1; sym1__ <= beta_raw_1dim__; ++sym1__) { + param_names__.emplace_back(std::string() + "beta_raw" + '.' + + std::to_string(sym1__)); + } + if (emit_transformed_parameters__) { + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + param_names__.emplace_back(std::string() + "beta" + '.' + + std::to_string(sym1__)); + } + } + if (emit_generated_quantities__) { + for (int sym1__ = 1; sym1__ <= beta_recovered_1dim__; ++sym1__) { + param_names__.emplace_back(std::string() + "beta_recovered" + '.' + + std::to_string(sym1__)); + } + } + } + inline void + unconstrained_param_names(std::vector& param_names__, bool + emit_transformed_parameters__ = true, bool + emit_generated_quantities__ = true) const final { + for (int sym1__ = 1; sym1__ <= beta_raw_1dim__; ++sym1__) { + param_names__.emplace_back(std::string() + "beta_raw" + '.' + + std::to_string(sym1__)); + } + if (emit_transformed_parameters__) { + for (int sym1__ = 1; sym1__ <= (K - 1); ++sym1__) { + param_names__.emplace_back(std::string() + "beta" + '.' + + std::to_string(sym1__)); + } + } + if (emit_generated_quantities__) { + for (int sym1__ = 1; sym1__ <= beta_recovered_1dim__; ++sym1__) { + param_names__.emplace_back(std::string() + "beta_recovered" + '.' + + std::to_string(sym1__)); + } + } + } + inline std::string get_constrained_sizedtypes() const { + return std::string("[{\"name\":\"beta_raw\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(beta_raw_1dim__) + "},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(K) + "},\"block\":\"transformed_parameters\"},{\"name\":\"beta_recovered\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(beta_recovered_1dim__) + "},\"block\":\"generated_quantities\"}]"); + } + inline std::string get_unconstrained_sizedtypes() const { + return std::string("[{\"name\":\"beta_raw\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(beta_raw_1dim__) + "},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string((K -1)) + "},\"block\":\"transformed_parameters\"},{\"name\":\"beta_recovered\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(beta_recovered_1dim__) + "},\"block\":\"generated_quantities\"}]"); + } + // Begin method overload boilerplate + template inline void + write_array(RNG& base_rng, Eigen::Matrix& params_r, + Eigen::Matrix& vars, const bool + emit_transformed_parameters = true, const bool + emit_generated_quantities = true, std::ostream* + pstream = nullptr) const { + const size_t num_params__ = beta_raw_1dim__; + const size_t num_transformed = emit_transformed_parameters * (K); + const size_t num_gen_quantities = emit_generated_quantities * + (beta_recovered_1dim__); + const size_t num_to_write = num_params__ + num_transformed + + num_gen_quantities; + std::vector params_i; + vars = Eigen::Matrix::Constant(num_to_write, + std::numeric_limits::quiet_NaN()); + write_array_impl(base_rng, params_r, params_i, vars, + emit_transformed_parameters, emit_generated_quantities, pstream); + } + template inline void + write_array(RNG& base_rng, std::vector& params_r, std::vector& + params_i, std::vector& vars, bool + emit_transformed_parameters = true, bool + emit_generated_quantities = true, std::ostream* + pstream = nullptr) const { + const size_t num_params__ = beta_raw_1dim__; + const size_t num_transformed = emit_transformed_parameters * (K); + const size_t num_gen_quantities = emit_generated_quantities * + (beta_recovered_1dim__); + const size_t num_to_write = num_params__ + num_transformed + + num_gen_quantities; + vars = std::vector(num_to_write, + std::numeric_limits::quiet_NaN()); + write_array_impl(base_rng, params_r, params_i, vars, + emit_transformed_parameters, emit_generated_quantities, pstream); + } + template inline T_ + log_prob(Eigen::Matrix& params_r, std::ostream* pstream = nullptr) const { + Eigen::Matrix params_i; + return log_prob_impl(params_r, params_i, pstream); + } + template inline T_ + log_prob(std::vector& params_r, std::vector& params_i, + std::ostream* pstream = nullptr) const { + return log_prob_impl(params_r, params_i, pstream); + } + inline void + transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, std::ostream* + pstream = nullptr) const final { + std::vector params_r_vec(params_r.size()); + std::vector params_i; + transform_inits(context, params_i, params_r_vec, pstream); + params_r = Eigen::Map>(params_r_vec.data(), + params_r_vec.size()); + } + inline void + transform_inits(const stan::io::var_context& context, std::vector& + params_i, std::vector& vars, std::ostream* + pstream__ = nullptr) const { + vars.resize(num_params_r__); + transform_inits_impl(context, vars, pstream__); + } + inline void + unconstrain_array(const std::vector& params_constrained, + std::vector& params_unconstrained, std::ostream* + pstream = nullptr) const { + const std::vector params_i; + params_unconstrained = std::vector(num_params_r__, + std::numeric_limits::quiet_NaN()); + unconstrain_array_impl(params_constrained, params_i, + params_unconstrained, pstream); + } + inline void + unconstrain_array(const Eigen::Matrix& params_constrained, + Eigen::Matrix& params_unconstrained, + std::ostream* pstream = nullptr) const { + const std::vector params_i; + params_unconstrained = Eigen::Matrix::Constant(num_params_r__, + std::numeric_limits::quiet_NaN()); + unconstrain_array_impl(params_constrained, params_i, + params_unconstrained, pstream); + } +}; +} +using stan_model = builtin_constraint_model_namespace::builtin_constraint_model; +#ifndef USING_R +// Boilerplate +stan::model::model_base& +new_model(stan::io::var_context& data_context, unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} +stan::math::profile_map& get_stan_profile_data() { + return builtin_constraint_model_namespace::profiles__; +} +#endif [exit 0] $ ../../../../../install/default/bin/stanc --print-cpp complex-tuples.stan // Code generated by %%NAME%% %%VERSION%% @@ -5691,29 +6200,33 @@ namespace jacobian_pe_model_namespace { using stan::model::model_base_crtp; using namespace stan::math; stan::math::profile_map profiles__; -static constexpr std::array locations_array__ = +static constexpr std::array locations_array__ = {" (found before start of program)", " (in 'jacobian_pe.stan', line 19, column 2 to column 13)", " (in 'jacobian_pe.stan', line 20, column 2 to column 22)", " (in 'jacobian_pe.stan', line 21, column 2 to column 20)", - " (in 'jacobian_pe.stan', line 24, column 2 to column 43)", - " (in 'jacobian_pe.stan', line 25, column 2 to column 55)", + " (in 'jacobian_pe.stan', line 24, column 2 to column 46)", + " (in 'jacobian_pe.stan', line 25, column 2 to column 58)", " (in 'jacobian_pe.stan', line 28, column 2 to column 41)", + " (in 'jacobian_pe.stan', line 32, column 2 to column 56)", " (in 'jacobian_pe.stan', line 27, column 2 to column 27)", + " (in 'jacobian_pe.stan', line 34, column 4 to column 56)", + " (in 'jacobian_pe.stan', line 33, column 32 to line 35, column 3)", + " (in 'jacobian_pe.stan', line 33, column 2 to line 35, column 3)", " (in 'jacobian_pe.stan', line 15, column 2 to column 10)", " (in 'jacobian_pe.stan', line 16, column 2 to column 8)", " (in 'jacobian_pe.stan', line 20, column 9 to column 10)", " (in 'jacobian_pe.stan', line 25, column 9 to column 10)", " (in 'jacobian_pe.stan', line 3, column 4 to column 18)", " (in 'jacobian_pe.stan', line 4, column 4 to column 23)", - " (in 'jacobian_pe.stan', line 2, column 45 to line 5, column 3)", + " (in 'jacobian_pe.stan', line 2, column 48 to line 5, column 3)", " (in 'jacobian_pe.stan', line 7, column 11 to column 18)", " (in 'jacobian_pe.stan', line 7, column 4 to column 27)", - " (in 'jacobian_pe.stan', line 9, column 6 to column 49)", + " (in 'jacobian_pe.stan', line 9, column 6 to column 52)", " (in 'jacobian_pe.stan', line 8, column 25 to line 10, column 5)", " (in 'jacobian_pe.stan', line 8, column 4 to line 10, column 5)", " (in 'jacobian_pe.stan', line 11, column 4 to column 18)", - " (in 'jacobian_pe.stan', line 6, column 49 to line 12, column 3)"}; + " (in 'jacobian_pe.stan', line 6, column 52 to line 12, column 3)"}; template , @@ -5721,8 +6234,8 @@ template , std::is_floating_point>>* = nullptr> stan::promote_args_t -upper_bound_jacobian(const T0__& x, const T1__& ub, T_lp__& lp__, - T_lp_accum__& lp_accum__, std::ostream* pstream__); +my_upper_bound_jacobian(const T0__& x, const T1__& ub, T_lp__& lp__, + T_lp_accum__& lp_accum__, std::ostream* pstream__); template , @@ -5730,9 +6243,9 @@ template , std::is_floating_point>>* = nullptr> Eigen::Matrix, T1__>,-1,1> -upper_bound_jacobian(const T0__& x_arg__, const T1__& ub, T_lp__& lp__, - T_lp_accum__& lp_accum__, std::ostream* pstream__); -// real upper_bound_jacobian(real, real) +my_upper_bound_jacobian(const T0__& x_arg__, const T1__& ub, T_lp__& lp__, + T_lp_accum__& lp_accum__, std::ostream* pstream__); +// real my_upper_bound_jacobian(real, real) template , @@ -5740,8 +6253,8 @@ template , std::is_floating_point>>*> stan::promote_args_t -upper_bound_jacobian(const T0__& x, const T1__& ub, T_lp__& lp__, - T_lp_accum__& lp_accum__, std::ostream* pstream__) { +my_upper_bound_jacobian(const T0__& x, const T1__& ub, T_lp__& lp__, + T_lp_accum__& lp_accum__, std::ostream* pstream__) { using local_scalar_t__ = stan::promote_args_t; int current_statement__ = 0; // suppress unused var warning @@ -5750,17 +6263,17 @@ upper_bound_jacobian(const T0__& x, const T1__& ub, T_lp__& lp__, // suppress unused var warning (void) DUMMY_VAR__; try { - current_statement__ = 12; + current_statement__ = 16; if (jacobian__) { lp_accum__.add(x); } - current_statement__ = 13; + current_statement__ = 17; return (ub - stan::math::exp(x)); } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); } } -// vector upper_bound_jacobian(vector, real) +// vector my_upper_bound_jacobian(vector, real) template , @@ -5768,8 +6281,8 @@ template , std::is_floating_point>>*> Eigen::Matrix, T1__>,-1,1> -upper_bound_jacobian(const T0__& x_arg__, const T1__& ub, T_lp__& lp__, - T_lp_accum__& lp_accum__, std::ostream* pstream__) { +my_upper_bound_jacobian(const T0__& x_arg__, const T1__& ub, T_lp__& lp__, + T_lp_accum__& lp_accum__, std::ostream* pstream__) { using local_scalar_t__ = stan::promote_args_t, T1__>; int current_statement__ = 0; @@ -5780,23 +6293,23 @@ upper_bound_jacobian(const T0__& x_arg__, const T1__& ub, T_lp__& lp__, // suppress unused var warning (void) DUMMY_VAR__; try { - current_statement__ = 15; + current_statement__ = 19; stan::math::validate_non_negative_index("result", "size(x)", stan::math::size(x)); Eigen::Matrix result = Eigen::Matrix::Constant(stan::math::size(x), DUMMY_VAR__); - current_statement__ = 19; + current_statement__ = 23; for (int n = 1; n <= stan::math::size(x); ++n) { - current_statement__ = 17; + current_statement__ = 21; stan::model::assign(result, - upper_bound_jacobian( + my_upper_bound_jacobian( stan::math::eval( stan::model::rvalue(x, "x", stan::model::index_uni(n))), ub, lp__, lp_accum__, pstream__), "assigning variable result", stan::model::index_uni(n)); } - current_statement__ = 20; + current_statement__ = 24; return result; } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); @@ -5826,21 +6339,21 @@ class jacobian_pe_model final : public model_base_crtp { // suppress unused var warning (void) DUMMY_VAR__; try { - current_statement__ = 8; + current_statement__ = 12; context__.validate_dims("data initialization", "ub", "double", std::vector{}); ub = std::numeric_limits::quiet_NaN(); - current_statement__ = 8; + current_statement__ = 12; ub = context__.vals_r("ub")[(1 - 1)]; - current_statement__ = 9; + current_statement__ = 13; context__.validate_dims("data initialization", "N", "int", std::vector{}); N = std::numeric_limits::min(); - current_statement__ = 9; + current_statement__ = 13; N = context__.vals_i("N")[(1 - 1)]; - current_statement__ = 10; + current_statement__ = 14; stan::math::validate_non_negative_index("b_vec_raw", "N", N); - current_statement__ = 11; + current_statement__ = 15; stan::math::validate_non_negative_index("bvec", "N", N); } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); @@ -5887,15 +6400,15 @@ class jacobian_pe_model final : public model_base_crtp { auto b_direct_raw = in__.template read(); local_scalar_t__ b = DUMMY_VAR__; current_statement__ = 4; - b = upper_bound_jacobian(b_raw, ub, lp__, lp_accum__, + b = my_upper_bound_jacobian(b_raw, ub, lp__, lp_accum__, pstream__); Eigen::Matrix bvec = Eigen::Matrix::Constant(N, DUMMY_VAR__); current_statement__ = 5; stan::model::assign(bvec, - upper_bound_jacobian(b_vec_raw, ub, lp__, lp_accum__, + my_upper_bound_jacobian(b_vec_raw, ub, lp__, lp_accum__, pstream__), "assigning variable bvec"); - current_statement__ = 7; + current_statement__ = 8; if (jacobian__) { lp_accum__.add(b_direct_raw); } @@ -5941,15 +6454,15 @@ class jacobian_pe_model final : public model_base_crtp { auto b_direct_raw = in__.template read(); local_scalar_t__ b = DUMMY_VAR__; current_statement__ = 4; - b = upper_bound_jacobian(b_raw, ub, lp__, lp_accum__, + b = my_upper_bound_jacobian(b_raw, ub, lp__, lp_accum__, pstream__); Eigen::Matrix bvec = Eigen::Matrix::Constant(N, DUMMY_VAR__); current_statement__ = 5; stan::model::assign(bvec, - upper_bound_jacobian(b_vec_raw, ub, lp__, lp_accum__, + my_upper_bound_jacobian(b_vec_raw, ub, lp__, lp_accum__, pstream__), "assigning variable bvec"); - current_statement__ = 7; + current_statement__ = 8; if (jacobian__) { lp_accum__.add(b_direct_raw); } @@ -6018,13 +6531,13 @@ class jacobian_pe_model final : public model_base_crtp { return ; } current_statement__ = 4; - b = upper_bound_jacobian(b_raw, ub, lp__, lp_accum__, + b = my_upper_bound_jacobian(b_raw, ub, lp__, lp_accum__, pstream__); current_statement__ = 5; stan::model::assign(bvec, - upper_bound_jacobian(b_vec_raw, ub, lp__, lp_accum__, + my_upper_bound_jacobian(b_vec_raw, ub, lp__, lp_accum__, pstream__), "assigning variable bvec"); - current_statement__ = 7; + current_statement__ = 8; if (jacobian__) { lp_accum__.add(b_direct_raw); } @@ -6038,6 +6551,20 @@ class jacobian_pe_model final : public model_base_crtp { if (stan::math::logical_negation(emit_generated_quantities__)) { return ; } + double b_raw_recovered = std::numeric_limits::quiet_NaN(); + current_statement__ = 7; + b_raw_recovered = stan::math::ub_free(b, ub); + current_statement__ = 11; + if (stan::math::logical_neq(b_raw_recovered, b_raw)) { + current_statement__ = 9; + { + std::stringstream errmsg_stream__; + stan::math::stan_print(&errmsg_stream__, + "b_raw_recovered does not match b_raw"); + throw std::runtime_error(errmsg_stream__.str()); + } + } + out__.write(b_raw_recovered); } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); } @@ -6137,7 +6664,11 @@ class jacobian_pe_model final : public model_base_crtp { names__.reserve(names__.size() + temp.size()); names__.insert(names__.end(), temp.begin(), temp.end()); } - if (emit_generated_quantities__) {} + if (emit_generated_quantities__) { + std::vector temp{"b_raw_recovered"}; + names__.reserve(names__.size() + temp.size()); + names__.insert(names__.end(), temp.begin(), temp.end()); + } } inline void get_dims(std::vector>& dimss__, const bool @@ -6154,7 +6685,11 @@ class jacobian_pe_model final : public model_base_crtp { dimss__.reserve(dimss__.size() + temp.size()); dimss__.insert(dimss__.end(), temp.begin(), temp.end()); } - if (emit_generated_quantities__) {} + if (emit_generated_quantities__) { + std::vector> temp{std::vector{}}; + dimss__.reserve(dimss__.size() + temp.size()); + dimss__.insert(dimss__.end(), temp.begin(), temp.end()); + } } inline void constrained_param_names(std::vector& param_names__, bool @@ -6174,7 +6709,9 @@ class jacobian_pe_model final : public model_base_crtp { } param_names__.emplace_back(std::string() + "b_direct"); } - if (emit_generated_quantities__) {} + if (emit_generated_quantities__) { + param_names__.emplace_back(std::string() + "b_raw_recovered"); + } } inline void unconstrained_param_names(std::vector& param_names__, bool @@ -6194,13 +6731,15 @@ class jacobian_pe_model final : public model_base_crtp { } param_names__.emplace_back(std::string() + "b_direct"); } - if (emit_generated_quantities__) {} + if (emit_generated_quantities__) { + param_names__.emplace_back(std::string() + "b_raw_recovered"); + } } inline std::string get_constrained_sizedtypes() const { - return std::string("[{\"name\":\"b_raw\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_vec_raw\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"b_direct_raw\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"bvec\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"},{\"name\":\"b_direct\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]"); + return std::string("[{\"name\":\"b_raw\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_vec_raw\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"b_direct_raw\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"bvec\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"},{\"name\":\"b_direct\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"b_raw_recovered\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"}]"); } inline std::string get_unconstrained_sizedtypes() const { - return std::string("[{\"name\":\"b_raw\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_vec_raw\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"b_direct_raw\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"bvec\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"},{\"name\":\"b_direct\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]"); + return std::string("[{\"name\":\"b_raw\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_vec_raw\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"b_direct_raw\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"bvec\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"},{\"name\":\"b_direct\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"b_raw_recovered\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"}]"); } // Begin method overload boilerplate template inline void @@ -6212,7 +6751,7 @@ class jacobian_pe_model final : public model_base_crtp { const size_t num_params__ = ((1 + N) + 1); const size_t num_transformed = emit_transformed_parameters * (((1 + N) + 1)); - const size_t num_gen_quantities = emit_generated_quantities * (0); + const size_t num_gen_quantities = emit_generated_quantities * (1); const size_t num_to_write = num_params__ + num_transformed + num_gen_quantities; std::vector params_i; @@ -6230,7 +6769,7 @@ class jacobian_pe_model final : public model_base_crtp { const size_t num_params__ = ((1 + N) + 1); const size_t num_transformed = emit_transformed_parameters * (((1 + N) + 1)); - const size_t num_gen_quantities = emit_generated_quantities * (0); + const size_t num_gen_quantities = emit_generated_quantities * (1); const size_t num_to_write = num_params__ + num_transformed + num_gen_quantities; vars = std::vector(num_to_write, diff --git a/test/integration/good/code-gen/jacobian_pe.stan b/test/integration/good/code-gen/jacobian_pe.stan index 1d1804d3e4..adb30789e9 100644 --- a/test/integration/good/code-gen/jacobian_pe.stan +++ b/test/integration/good/code-gen/jacobian_pe.stan @@ -1,12 +1,12 @@ functions { - real upper_bound_jacobian(real x, real ub) { + real my_upper_bound_jacobian(real x, real ub) { jacobian += x; return ub - exp(x); } - vector upper_bound_jacobian(vector x, real ub) { + vector my_upper_bound_jacobian(vector x, real ub) { vector[size(x)] result; for (n in 1:size(x)) { - result[n] = upper_bound_jacobian(x[n], ub); + result[n] = my_upper_bound_jacobian(x[n], ub); } return result; } @@ -21,10 +21,17 @@ parameters { real b_direct_raw; } transformed parameters { - real b = upper_bound_jacobian(b_raw, ub); - vector[N] bvec = upper_bound_jacobian(b_vec_raw, ub); + real b = my_upper_bound_jacobian(b_raw, ub); + vector[N] bvec = my_upper_bound_jacobian(b_vec_raw, ub); jacobian += b_direct_raw; real b_direct = ub - exp(b_direct_raw); } +generated quantities { + real b_raw_recovered = upper_bound_unconstrain(b, ub); + if (b_raw_recovered != b_raw) { + fatal_error("b_raw_recovered does not match b_raw"); + } +} + diff --git a/test/integration/good/code-gen/standalone_functions/basic.stan b/test/integration/good/code-gen/standalone_functions/basic.stan index 8b7ace7ad2..f257460d26 100644 --- a/test/integration/good/code-gen/standalone_functions/basic.stan +++ b/test/integration/good/code-gen/standalone_functions/basic.stan @@ -46,7 +46,7 @@ functions { return a; } - vector upper_bound_jacobian(vector x, real ub) { + vector my_upper_bound_jacobian(vector x, real ub) { jacobian += x; return ub - exp(x); } diff --git a/test/integration/good/code-gen/standalone_functions/cpp.expected b/test/integration/good/code-gen/standalone_functions/cpp.expected index 2a9fd9480a..0ae5303529 100644 --- a/test/integration/good/code-gen/standalone_functions/cpp.expected +++ b/test/integration/good/code-gen/standalone_functions/cpp.expected @@ -33,7 +33,7 @@ static constexpr std::array locations_array__ = " (in 'basic.stan', line 45, column 51 to line 47, column 3)", " (in 'basic.stan', line 50, column 4 to column 18)", " (in 'basic.stan', line 51, column 4 to column 23)", - " (in 'basic.stan', line 49, column 49 to line 52, column 3)"}; + " (in 'basic.stan', line 49, column 52 to line 52, column 3)"}; template , std::is_floating_point>>* = nullptr> @@ -117,8 +117,8 @@ template , std::is_floating_point>>* = nullptr> Eigen::Matrix, T1__>,-1,1> -upper_bound_jacobian(const T0__& x_arg__, const T1__& ub, T_lp__& lp__, - T_lp_accum__& lp_accum__, std::ostream* pstream__); +my_upper_bound_jacobian(const T0__& x_arg__, const T1__& ub, T_lp__& lp__, + T_lp_accum__& lp_accum__, std::ostream* pstream__); // real my_log1p_exp(real) template , @@ -398,7 +398,7 @@ array_fun(const T0__& a, std::ostream* pstream__) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); } } -// vector upper_bound_jacobian(vector, real) +// vector my_upper_bound_jacobian(vector, real) template , @@ -406,8 +406,8 @@ template , std::is_floating_point>>*> Eigen::Matrix, T1__>,-1,1> -upper_bound_jacobian(const T0__& x_arg__, const T1__& ub, T_lp__& lp__, - T_lp_accum__& lp_accum__, std::ostream* pstream__) { +my_upper_bound_jacobian(const T0__& x_arg__, const T1__& ub, T_lp__& lp__, + T_lp_accum__& lp_accum__, std::ostream* pstream__) { using local_scalar_t__ = stan::promote_args_t, T1__>; int current_statement__ = 0; @@ -490,10 +490,10 @@ array_fun(const std::vector>>>& } // [[stan::function]] Eigen::Matrix -upper_bound_jacobian(const Eigen::Matrix& x, const double& ub, - double& lp__, stan::math::accumulator& - lp_accum__, std::ostream* pstream__ = nullptr) { - return basic_model_namespace::upper_bound_jacobian(x, ub, lp__, +my_upper_bound_jacobian(const Eigen::Matrix& x, const double& + ub, double& lp__, stan::math::accumulator& + lp_accum__, std::ostream* pstream__ = nullptr) { + return basic_model_namespace::my_upper_bound_jacobian(x, ub, lp__, lp_accum__, pstream__); } [exit 0] diff --git a/test/integration/good/code-gen/standalone_functions/stanc.expected b/test/integration/good/code-gen/standalone_functions/stanc.expected index bc7116f9f0..90cb3a95d2 100644 --- a/test/integration/good/code-gen/standalone_functions/stanc.expected +++ b/test/integration/good/code-gen/standalone_functions/stanc.expected @@ -46,7 +46,7 @@ functions { return a; } - vector upper_bound_jacobian(vector x, real ub) { + vector my_upper_bound_jacobian(vector x, real ub) { jacobian += x; return ub - exp(x); } diff --git a/test/integration/good/compiler-optimizations/mem_patterns/constraints.stan b/test/integration/good/compiler-optimizations/mem_patterns/constraints.stan index 3abf78d75b..d0893df91c 100644 --- a/test/integration/good/compiler-optimizations/mem_patterns/constraints.stan +++ b/test/integration/good/compiler-optimizations/mem_patterns/constraints.stan @@ -65,6 +65,8 @@ transformed parameters { h_i_sigma[2:Nr] = rep_vector(1.0, (Nr - 1)); h_i_mean[2:Nr] = phi * h[1:(Nr-1)] + theta * square(err[1:(Nr - 1)]); vector[Nr] h_sigma = exp(h * (0.5 * sigma) + (0.5 * mu)) + 0.000001; + + vector[N] means_ordered = ordered_jacobian(mean_price); } model { diff --git a/test/integration/good/compiler-optimizations/mem_patterns/cpp.expected b/test/integration/good/compiler-optimizations/mem_patterns/cpp.expected index c61772fe10..18e7a894cb 100644 --- a/test/integration/good/compiler-optimizations/mem_patterns/cpp.expected +++ b/test/integration/good/compiler-optimizations/mem_patterns/cpp.expected @@ -1213,7 +1213,7 @@ namespace constraints_model_namespace { using stan::model::model_base_crtp; using namespace stan::math; stan::math::profile_map profiles__; -static constexpr std::array locations_array__ = +static constexpr std::array locations_array__ = {" (found before start of program)", " (in 'constraints.stan', line 20, column 2 to column 66)", " (in 'constraints.stan', line 21, column 2 to column 14)", @@ -1246,6 +1246,7 @@ static constexpr std::array locations_array__ = " (in 'constraints.stan', line 61, column 2 to column 22)", " (in 'constraints.stan', line 62, column 2 to column 32)", " (in 'constraints.stan', line 67, column 2 to column 70)", + " (in 'constraints.stan', line 69, column 2 to column 57)", " (in 'constraints.stan', line 56, column 2 to column 25)", " (in 'constraints.stan', line 57, column 2 to column 67)", " (in 'constraints.stan', line 58, column 2 to column 46)", @@ -1254,17 +1255,17 @@ static constexpr std::array locations_array__ = " (in 'constraints.stan', line 64, column 2 to column 44)", " (in 'constraints.stan', line 65, column 2 to column 46)", " (in 'constraints.stan', line 66, column 2 to column 71)", - " (in 'constraints.stan', line 72, column 2 to column 34)", - " (in 'constraints.stan', line 73, column 2 to column 50)", - " (in 'constraints.stan', line 74, column 2 to column 44)", - " (in 'constraints.stan', line 75, column 2 to column 54)", - " (in 'constraints.stan', line 76, column 2 to column 21)", - " (in 'constraints.stan', line 77, column 2 to column 21)", - " (in 'constraints.stan', line 78, column 2 to column 34)", - " (in 'constraints.stan', line 79, column 2 to column 35)", - " (in 'constraints.stan', line 80, column 2 to column 54)", - " (in 'constraints.stan', line 81, column 2 to column 43)", - " (in 'constraints.stan', line 82, column 2 to column 36)", + " (in 'constraints.stan', line 74, column 2 to column 34)", + " (in 'constraints.stan', line 75, column 2 to column 50)", + " (in 'constraints.stan', line 76, column 2 to column 44)", + " (in 'constraints.stan', line 77, column 2 to column 54)", + " (in 'constraints.stan', line 78, column 2 to column 21)", + " (in 'constraints.stan', line 79, column 2 to column 21)", + " (in 'constraints.stan', line 80, column 2 to column 34)", + " (in 'constraints.stan', line 81, column 2 to column 35)", + " (in 'constraints.stan', line 82, column 2 to column 54)", + " (in 'constraints.stan', line 83, column 2 to column 43)", + " (in 'constraints.stan', line 84, column 2 to column 36)", " (in 'constraints.stan', line 3, column 2 to column 17)", " (in 'constraints.stan', line 4, column 2 to column 17)", " (in 'constraints.stan', line 5, column 9 to column 10)", @@ -1305,7 +1306,8 @@ static constexpr std::array locations_array__ = " (in 'constraints.stan', line 54, column 9 to column 11)", " (in 'constraints.stan', line 61, column 9 to column 11)", " (in 'constraints.stan', line 62, column 18 to column 20)", - " (in 'constraints.stan', line 67, column 9 to column 11)"}; + " (in 'constraints.stan', line 67, column 9 to column 11)", + " (in 'constraints.stan', line 69, column 9 to column 10)"}; class constraints_model final : public model_base_crtp { private: int N; @@ -1347,25 +1349,25 @@ class constraints_model final : public model_base_crtp { try { int pos__ = std::numeric_limits::min(); pos__ = 1; - current_statement__ = 51; + current_statement__ = 52; context__.validate_dims("data initialization", "N", "int", std::vector{}); N = std::numeric_limits::min(); - current_statement__ = 51; + current_statement__ = 52; N = context__.vals_i("N")[(1 - 1)]; - current_statement__ = 51; - stan::math::check_greater_or_equal(function__, "N", N, 0); current_statement__ = 52; + stan::math::check_greater_or_equal(function__, "N", N, 0); + current_statement__ = 53; context__.validate_dims("data initialization", "K", "int", std::vector{}); K = std::numeric_limits::min(); - current_statement__ = 52; + current_statement__ = 53; K = context__.vals_i("K")[(1 - 1)]; - current_statement__ = 52; - stan::math::check_greater_or_equal(function__, "K", K, 1); current_statement__ = 53; - stan::math::validate_non_negative_index("diff_low_mid", "N", N); + stan::math::check_greater_or_equal(function__, "K", K, 1); current_statement__ = 54; + stan::math::validate_non_negative_index("diff_low_mid", "N", N); + current_statement__ = 55; context__.validate_dims("data initialization", "diff_low_mid", "double", std::vector{static_cast(N)}); diff_low_mid_data__ = Eigen::Matrix::Constant(N, @@ -1374,7 +1376,7 @@ class constraints_model final : public model_base_crtp { Eigen::Map>(diff_low_mid_data__.data(), N); { std::vector diff_low_mid_flat__; - current_statement__ = 54; + current_statement__ = 55; diff_low_mid_flat__ = context__.vals_r("diff_low_mid"); pos__ = 1; for (int sym1__ = 1; sym1__ <= N; ++sym1__) { @@ -1383,9 +1385,9 @@ class constraints_model final : public model_base_crtp { pos__ = (pos__ + 1); } } - current_statement__ = 55; - stan::math::validate_non_negative_index("diff_high_mid", "N", N); current_statement__ = 56; + stan::math::validate_non_negative_index("diff_high_mid", "N", N); + current_statement__ = 57; context__.validate_dims("data initialization", "diff_high_mid", "double", std::vector{static_cast(N)}); diff_high_mid_data__ = Eigen::Matrix::Constant(N, @@ -1395,7 +1397,7 @@ class constraints_model final : public model_base_crtp { N); { std::vector diff_high_mid_flat__; - current_statement__ = 56; + current_statement__ = 57; diff_high_mid_flat__ = context__.vals_r("diff_high_mid"); pos__ = 1; for (int sym1__ = 1; sym1__ <= N; ++sym1__) { @@ -1405,9 +1407,9 @@ class constraints_model final : public model_base_crtp { pos__ = (pos__ + 1); } } - current_statement__ = 57; - stan::math::validate_non_negative_index("mid_price", "N", N); current_statement__ = 58; + stan::math::validate_non_negative_index("mid_price", "N", N); + current_statement__ = 59; context__.validate_dims("data initialization", "mid_price", "double", std::vector{static_cast(N)}); mid_price_data__ = Eigen::Matrix::Constant(N, @@ -1416,7 +1418,7 @@ class constraints_model final : public model_base_crtp { Eigen::Map>(mid_price_data__.data(), N); { std::vector mid_price_flat__; - current_statement__ = 58; + current_statement__ = 59; mid_price_flat__ = context__.vals_r("mid_price"); pos__ = 1; for (int sym1__ = 1; sym1__ <= N; ++sym1__) { @@ -1425,11 +1427,11 @@ class constraints_model final : public model_base_crtp { pos__ = (pos__ + 1); } } - current_statement__ = 59; - stan::math::validate_non_negative_index("X_all", "N", N); current_statement__ = 60; - stan::math::validate_non_negative_index("X_all", "K", K); + stan::math::validate_non_negative_index("X_all", "N", N); current_statement__ = 61; + stan::math::validate_non_negative_index("X_all", "K", K); + current_statement__ = 62; context__.validate_dims("data initialization", "X_all", "double", std::vector{static_cast(N), static_cast(K)}); X_all_data__ = Eigen::Matrix::Constant(N, K, @@ -1438,7 +1440,7 @@ class constraints_model final : public model_base_crtp { Eigen::Map>(X_all_data__.data(), N, K); { std::vector X_all_flat__; - current_statement__ = 61; + current_statement__ = 62; X_all_flat__ = context__.vals_r("X_all"); pos__ = 1; for (int sym1__ = 1; sym1__ <= K; ++sym1__) { @@ -1450,120 +1452,122 @@ class constraints_model final : public model_base_crtp { } } } - current_statement__ = 62; + current_statement__ = 63; context__.validate_dims("data initialization", "phi_prior_a", "double", std::vector{}); phi_prior_a = std::numeric_limits::quiet_NaN(); - current_statement__ = 62; + current_statement__ = 63; phi_prior_a = context__.vals_r("phi_prior_a")[(1 - 1)]; - current_statement__ = 62; + current_statement__ = 63; stan::math::check_greater_or_equal(function__, "phi_prior_a", phi_prior_a, 0); - current_statement__ = 63; + current_statement__ = 64; context__.validate_dims("data initialization", "phi_prior_b", "double", std::vector{}); phi_prior_b = std::numeric_limits::quiet_NaN(); - current_statement__ = 63; + current_statement__ = 64; phi_prior_b = context__.vals_r("phi_prior_b")[(1 - 1)]; - current_statement__ = 63; + current_statement__ = 64; stan::math::check_greater_or_equal(function__, "phi_prior_b", phi_prior_b, 0); - current_statement__ = 64; + current_statement__ = 65; context__.validate_dims("data initialization", "mu_prior_mu", "double", std::vector{}); mu_prior_mu = std::numeric_limits::quiet_NaN(); - current_statement__ = 64; - mu_prior_mu = context__.vals_r("mu_prior_mu")[(1 - 1)]; current_statement__ = 65; + mu_prior_mu = context__.vals_r("mu_prior_mu")[(1 - 1)]; + current_statement__ = 66; context__.validate_dims("data initialization", "mu_prior_sigma", "double", std::vector{}); mu_prior_sigma = std::numeric_limits::quiet_NaN(); - current_statement__ = 65; + current_statement__ = 66; mu_prior_sigma = context__.vals_r("mu_prior_sigma")[(1 - 1)]; - current_statement__ = 65; + current_statement__ = 66; stan::math::check_greater_or_equal(function__, "mu_prior_sigma", mu_prior_sigma, 0); - current_statement__ = 66; + current_statement__ = 67; context__.validate_dims("data initialization", "sigma_prior_shape", "double", std::vector{}); sigma_prior_shape = std::numeric_limits::quiet_NaN(); - current_statement__ = 66; + current_statement__ = 67; sigma_prior_shape = context__.vals_r("sigma_prior_shape")[(1 - 1)]; - current_statement__ = 66; + current_statement__ = 67; stan::math::check_greater_or_equal(function__, "sigma_prior_shape", sigma_prior_shape, 0); - current_statement__ = 67; + current_statement__ = 68; context__.validate_dims("data initialization", "sigma_prior_rate", "double", std::vector{}); sigma_prior_rate = std::numeric_limits::quiet_NaN(); - current_statement__ = 67; + current_statement__ = 68; sigma_prior_rate = context__.vals_r("sigma_prior_rate")[(1 - 1)]; - current_statement__ = 67; + current_statement__ = 68; stan::math::check_greater_or_equal(function__, "sigma_prior_rate", sigma_prior_rate, 0); - current_statement__ = 68; + current_statement__ = 69; Nr = std::numeric_limits::min(); - current_statement__ = 68; - Nr = (N - 1); current_statement__ = 69; - stan::math::validate_non_negative_index("high_low_est", "N", N); + Nr = (N - 1); current_statement__ = 70; - stan::math::validate_non_negative_index("b", "K", K); + stan::math::validate_non_negative_index("high_low_est", "N", N); current_statement__ = 71; - stan::math::validate_non_negative_index("h", "Nr", Nr); + stan::math::validate_non_negative_index("b", "K", K); current_statement__ = 72; - stan::math::validate_non_negative_index("mean_price", "N", N); + stan::math::validate_non_negative_index("h", "Nr", Nr); current_statement__ = 73; - stan::math::validate_non_negative_index("sigma_price", "N", N); + stan::math::validate_non_negative_index("mean_price", "N", N); current_statement__ = 74; - stan::math::validate_non_negative_index("upper_test", "N", N); + stan::math::validate_non_negative_index("sigma_price", "N", N); current_statement__ = 75; - stan::math::validate_non_negative_index("lower_upper_test", "N", N); + stan::math::validate_non_negative_index("upper_test", "N", N); current_statement__ = 76; + stan::math::validate_non_negative_index("lower_upper_test", "N", N); + current_statement__ = 77; stan::math::validate_non_negative_index("row_vec_lower_upper_test", "N", N); - current_statement__ = 77; - stan::math::validate_non_negative_index("offset_mult_test", "N", N); current_statement__ = 78; - stan::math::validate_non_negative_index("ordered_test", "N", N); + stan::math::validate_non_negative_index("offset_mult_test", "N", N); current_statement__ = 79; - stan::math::validate_unit_vector_index("unit_vec_test", "N", N); + stan::math::validate_non_negative_index("ordered_test", "N", N); current_statement__ = 80; - stan::math::validate_non_negative_index("pos_ordered_test", "N", N); - current_statement__ = 81; - stan::math::validate_non_negative_index("corr_matrix_test", "N", N); + stan::math::validate_unit_vector_index("unit_vec_test", "N", N); current_statement__ = 81; - stan::math::validate_non_negative_index("corr_matrix_test", "N", N); + stan::math::validate_non_negative_index("pos_ordered_test", "N", N); current_statement__ = 82; - stan::math::validate_non_negative_index("cov_matrix_test", "N", N); + stan::math::validate_non_negative_index("corr_matrix_test", "N", N); current_statement__ = 82; + stan::math::validate_non_negative_index("corr_matrix_test", "N", N); + current_statement__ = 83; stan::math::validate_non_negative_index("cov_matrix_test", "N", N); current_statement__ = 83; + stan::math::validate_non_negative_index("cov_matrix_test", "N", N); + current_statement__ = 84; stan::math::validate_non_negative_index("chol_fac_cov_test", "K", K); - current_statement__ = 83; + current_statement__ = 84; stan::math::validate_non_negative_index("chol_fac_cov_test", "K", K); - current_statement__ = 83; + current_statement__ = 84; stan::math::check_greater_or_equal( "cholesky_factor_cov chol_fac_cov_test", "num rows (must be greater or equal to num cols)", K, K); - current_statement__ = 84; - stan::math::validate_non_negative_index("chol_fac_corr_test", "K", K); - current_statement__ = 84; + current_statement__ = 85; stan::math::validate_non_negative_index("chol_fac_corr_test", "K", K); current_statement__ = 85; - stan::math::validate_non_negative_index("prices", "N", N); + stan::math::validate_non_negative_index("chol_fac_corr_test", "K", K); current_statement__ = 86; - stan::math::validate_non_negative_index("prices_diff", "Nr", Nr); + stan::math::validate_non_negative_index("prices", "N", N); current_statement__ = 87; - stan::math::validate_non_negative_index("mu", "Nr", Nr); + stan::math::validate_non_negative_index("prices_diff", "Nr", Nr); current_statement__ = 88; - stan::math::validate_non_negative_index("err", "Nr", Nr); + stan::math::validate_non_negative_index("mu", "Nr", Nr); current_statement__ = 89; - stan::math::validate_non_negative_index("h_i_mean", "Nr", Nr); + stan::math::validate_non_negative_index("err", "Nr", Nr); current_statement__ = 90; - stan::math::validate_non_negative_index("h_i_sigma", "Nr", Nr); + stan::math::validate_non_negative_index("h_i_mean", "Nr", Nr); current_statement__ = 91; + stan::math::validate_non_negative_index("h_i_sigma", "Nr", Nr); + current_statement__ = 92; stan::math::validate_non_negative_index("h_sigma", "Nr", Nr); + current_statement__ = 93; + stan::math::validate_non_negative_index("means_ordered", "N", N); } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); } @@ -1737,10 +1741,10 @@ class constraints_model final : public model_base_crtp { "assigning variable mu"); Eigen::Matrix err = Eigen::Matrix::Constant(Nr, DUMMY_VAR__); - current_statement__ = 32; + current_statement__ = 33; stan::model::assign(err, stan::math::subtract(prices_diff, mu), "assigning variable err"); - current_statement__ = 33; + current_statement__ = 34; stan::model::assign(mu, stan::math::add( stan::model::deep_copy( @@ -1754,7 +1758,7 @@ class constraints_model final : public model_base_crtp { stan::model::index_min_max(1, (Nr - 1))), stan::model::rvalue(ar, "ar", stan::model::index_uni(1))))), "assigning variable mu", stan::model::index_min_max(2, Nr)); - current_statement__ = 34; + current_statement__ = 35; stan::model::assign(mu, stan::math::add( stan::model::deep_copy( @@ -1764,24 +1768,24 @@ class constraints_model final : public model_base_crtp { stan::model::index_min_max(1, (Nr - 2))), stan::model::rvalue(ar, "ar", stan::model::index_uni(2)))), "assigning variable mu", stan::model::index_min_max(3, Nr)); - current_statement__ = 35; + current_statement__ = 36; stan::model::assign(err, stan::math::subtract(prices_diff, mu), "assigning variable err"); Eigen::Matrix h_i_mean = Eigen::Matrix::Constant(Nr, DUMMY_VAR__); Eigen::Matrix h_i_sigma = Eigen::Matrix::Constant(Nr, DUMMY_VAR__); - current_statement__ = 36; + current_statement__ = 37; stan::model::assign(h_i_mean, 0.0, "assigning variable h_i_mean", stan::model::index_uni(1)); - current_statement__ = 37; + current_statement__ = 38; stan::model::assign(h_i_sigma, stan::math::pow((1 - stan::math::square(phi)), -(0.5)), "assigning variable h_i_sigma", stan::model::index_uni(1)); - current_statement__ = 38; + current_statement__ = 39; stan::model::assign(h_i_sigma, stan::math::rep_vector(1.0, (Nr - 1)), "assigning variable h_i_sigma", stan::model::index_min_max(2, Nr)); - current_statement__ = 39; + current_statement__ = 40; stan::model::assign(h_i_mean, stan::math::add( stan::math::multiply(phi, @@ -1801,6 +1805,12 @@ class constraints_model final : public model_base_crtp { stan::math::add(stan::math::multiply(h, (0.5 * sigma)), stan::math::multiply(0.5, mu))), 0.000001), "assigning variable h_sigma"); + Eigen::Matrix means_ordered = + Eigen::Matrix::Constant(N, DUMMY_VAR__); + current_statement__ = 32; + stan::model::assign(means_ordered, + stan::math::ordered_constrain(mean_price, lp__), + "assigning variable means_ordered"); current_statement__ = 23; stan::math::check_greater_or_equal(function__, "phi", phi, -(1)); current_statement__ = 23; @@ -1811,35 +1821,35 @@ class constraints_model final : public model_base_crtp { stan::math::check_greater_or_equal(function__, "h_i_sigma", h_i_sigma, 0); { - current_statement__ = 40; + current_statement__ = 41; lp_accum__.add(stan::math::multiply(-(2), stan::math::log(sigma_price))); - current_statement__ = 41; + current_statement__ = 42; lp_accum__.add(stan::math::normal_lpdf(Intercept, mu_prior_mu, mu_prior_sigma)); - current_statement__ = 42; + current_statement__ = 43; lp_accum__.add(stan::math::beta_lpdf(phi_beta, phi_prior_a, phi_prior_b)); - current_statement__ = 43; + current_statement__ = 44; lp_accum__.add(stan::math::gamma_lpdf(sigma2, sigma_prior_shape, sigma_prior_rate)); - current_statement__ = 44; - lp_accum__.add(stan::math::normal_lpdf(ar, 0, .2)); current_statement__ = 45; - lp_accum__.add(stan::math::normal_lpdf(ma, 0, .2)); + lp_accum__.add(stan::math::normal_lpdf(ar, 0, .2)); current_statement__ = 46; + lp_accum__.add(stan::math::normal_lpdf(ma, 0, .2)); + current_statement__ = 47; lp_accum__.add(stan::math::normal_lpdf(h, h_i_mean, h_i_sigma)); - current_statement__ = 47; + current_statement__ = 48; lp_accum__.add(stan::math::student_t_lpdf(sigma_price, 3, 1, 1)); - current_statement__ = 48; + current_statement__ = 49; lp_accum__.add(stan::math::uniform_lpdf(high_low_est, diff_low_mid, diff_high_mid)); - current_statement__ = 49; + current_statement__ = 50; lp_accum__.add(stan::math::normal_lpdf(prices, mean_price, sigma_price)); - current_statement__ = 50; + current_statement__ = 51; lp_accum__.add(stan::math::normal_lpdf(prices_diff, mu, h_sigma)); } @@ -2032,10 +2042,10 @@ class constraints_model final : public model_base_crtp { stan::math::var_value>(Eigen::Matrix::Constant(Nr, std::numeric_limits::quiet_NaN( ))); - current_statement__ = 32; + current_statement__ = 33; stan::model::assign(err, stan::math::subtract(prices_diff, mu), "assigning variable err"); - current_statement__ = 33; + current_statement__ = 34; stan::model::assign(mu, stan::math::add( stan::model::deep_copy( @@ -2049,7 +2059,7 @@ class constraints_model final : public model_base_crtp { stan::model::index_min_max(1, (Nr - 1))), stan::model::rvalue(ar, "ar", stan::model::index_uni(1))))), "assigning variable mu", stan::model::index_min_max(2, Nr)); - current_statement__ = 34; + current_statement__ = 35; stan::model::assign(mu, stan::math::add( stan::model::deep_copy( @@ -2059,7 +2069,7 @@ class constraints_model final : public model_base_crtp { stan::model::index_min_max(1, (Nr - 2))), stan::model::rvalue(ar, "ar", stan::model::index_uni(2)))), "assigning variable mu", stan::model::index_min_max(3, Nr)); - current_statement__ = 35; + current_statement__ = 36; stan::model::assign(err, stan::math::subtract(prices_diff, mu), "assigning variable err"); stan::math::var_value> h_i_mean = @@ -2070,17 +2080,17 @@ class constraints_model final : public model_base_crtp { stan::math::var_value>(Eigen::Matrix::Constant(Nr, std::numeric_limits::quiet_NaN( ))); - current_statement__ = 36; + current_statement__ = 37; stan::model::assign(h_i_mean, 0.0, "assigning variable h_i_mean", stan::model::index_uni(1)); - current_statement__ = 37; + current_statement__ = 38; stan::model::assign(h_i_sigma, stan::math::pow((1 - stan::math::square(phi)), -(0.5)), "assigning variable h_i_sigma", stan::model::index_uni(1)); - current_statement__ = 38; + current_statement__ = 39; stan::model::assign(h_i_sigma, stan::math::rep_vector(1.0, (Nr - 1)), "assigning variable h_i_sigma", stan::model::index_min_max(2, Nr)); - current_statement__ = 39; + current_statement__ = 40; stan::model::assign(h_i_mean, stan::math::add( stan::math::multiply(phi, @@ -2102,6 +2112,14 @@ class constraints_model final : public model_base_crtp { stan::math::add(stan::math::multiply(h, (0.5 * sigma)), stan::math::multiply(0.5, mu))), 0.000001), "assigning variable h_sigma"); + stan::math::var_value> means_ordered = + stan::math::var_value>(Eigen::Matrix::Constant(N, + std::numeric_limits::quiet_NaN( + ))); + current_statement__ = 32; + stan::model::assign(means_ordered, + stan::math::ordered_constrain(mean_price, lp__), + "assigning variable means_ordered"); current_statement__ = 23; stan::math::check_greater_or_equal(function__, "phi", phi, -(1)); current_statement__ = 23; @@ -2112,35 +2130,35 @@ class constraints_model final : public model_base_crtp { stan::math::check_greater_or_equal(function__, "h_i_sigma", h_i_sigma, 0); { - current_statement__ = 40; + current_statement__ = 41; lp_accum__.add(stan::math::multiply(-(2), stan::math::log(sigma_price))); - current_statement__ = 41; + current_statement__ = 42; lp_accum__.add(stan::math::normal_lpdf(Intercept, mu_prior_mu, mu_prior_sigma)); - current_statement__ = 42; + current_statement__ = 43; lp_accum__.add(stan::math::beta_lpdf(phi_beta, phi_prior_a, phi_prior_b)); - current_statement__ = 43; + current_statement__ = 44; lp_accum__.add(stan::math::gamma_lpdf(sigma2, sigma_prior_shape, sigma_prior_rate)); - current_statement__ = 44; - lp_accum__.add(stan::math::normal_lpdf(ar, 0, .2)); current_statement__ = 45; - lp_accum__.add(stan::math::normal_lpdf(ma, 0, .2)); + lp_accum__.add(stan::math::normal_lpdf(ar, 0, .2)); current_statement__ = 46; + lp_accum__.add(stan::math::normal_lpdf(ma, 0, .2)); + current_statement__ = 47; lp_accum__.add(stan::math::normal_lpdf(h, h_i_mean, h_i_sigma)); - current_statement__ = 47; + current_statement__ = 48; lp_accum__.add(stan::math::student_t_lpdf(sigma_price, 3, 1, 1)); - current_statement__ = 48; + current_statement__ = 49; lp_accum__.add(stan::math::uniform_lpdf(high_low_est, diff_low_mid, diff_high_mid)); - current_statement__ = 49; + current_statement__ = 50; lp_accum__.add(stan::math::normal_lpdf(prices, mean_price, sigma_price)); - current_statement__ = 50; + current_statement__ = 51; lp_accum__.add(stan::math::normal_lpdf(prices_diff, mu, h_sigma)); } @@ -2314,6 +2332,9 @@ class constraints_model final : public model_base_crtp { Eigen::Matrix h_sigma = Eigen::Matrix::Constant(Nr, std::numeric_limits::quiet_NaN()); + Eigen::Matrix means_ordered = + Eigen::Matrix::Constant(N, + std::numeric_limits::quiet_NaN()); out__.write(high_low_est); out__.write(b); out__.write(h); @@ -2360,10 +2381,10 @@ class constraints_model final : public model_base_crtp { stan::model::assign(mu, stan::math::add(Intercept, stan::math::multiply(X_all, b)), "assigning variable mu"); - current_statement__ = 32; + current_statement__ = 33; stan::model::assign(err, stan::math::subtract(prices_diff, mu), "assigning variable err"); - current_statement__ = 33; + current_statement__ = 34; stan::model::assign(mu, stan::math::add( stan::model::deep_copy( @@ -2377,7 +2398,7 @@ class constraints_model final : public model_base_crtp { stan::model::index_min_max(1, (Nr - 1))), stan::model::rvalue(ar, "ar", stan::model::index_uni(1))))), "assigning variable mu", stan::model::index_min_max(2, Nr)); - current_statement__ = 34; + current_statement__ = 35; stan::model::assign(mu, stan::math::add( stan::model::deep_copy( @@ -2387,20 +2408,20 @@ class constraints_model final : public model_base_crtp { stan::model::index_min_max(1, (Nr - 2))), stan::model::rvalue(ar, "ar", stan::model::index_uni(2)))), "assigning variable mu", stan::model::index_min_max(3, Nr)); - current_statement__ = 35; + current_statement__ = 36; stan::model::assign(err, stan::math::subtract(prices_diff, mu), "assigning variable err"); - current_statement__ = 36; + current_statement__ = 37; stan::model::assign(h_i_mean, 0.0, "assigning variable h_i_mean", stan::model::index_uni(1)); - current_statement__ = 37; + current_statement__ = 38; stan::model::assign(h_i_sigma, stan::math::pow((1 - stan::math::square(phi)), -(0.5)), "assigning variable h_i_sigma", stan::model::index_uni(1)); - current_statement__ = 38; + current_statement__ = 39; stan::model::assign(h_i_sigma, stan::math::rep_vector(1.0, (Nr - 1)), "assigning variable h_i_sigma", stan::model::index_min_max(2, Nr)); - current_statement__ = 39; + current_statement__ = 40; stan::model::assign(h_i_mean, stan::math::add( stan::math::multiply(phi, @@ -2418,6 +2439,10 @@ class constraints_model final : public model_base_crtp { stan::math::add(stan::math::multiply(h, (0.5 * sigma)), stan::math::multiply(0.5, mu))), 0.000001), "assigning variable h_sigma"); + current_statement__ = 32; + stan::model::assign(means_ordered, + stan::math::ordered_constrain(mean_price, lp__), + "assigning variable means_ordered"); current_statement__ = 23; stan::math::check_greater_or_equal(function__, "phi", phi, -(1)); current_statement__ = 23; @@ -2437,6 +2462,7 @@ class constraints_model final : public model_base_crtp { out__.write(h_i_mean); out__.write(h_i_sigma); out__.write(h_sigma); + out__.write(means_ordered); } if (stan::math::logical_negation(emit_generated_quantities__)) { return ; @@ -2995,7 +3021,7 @@ class constraints_model final : public model_base_crtp { if (emit_transformed_parameters__) { std::vector temp{"phi", "sigma", "prices", "prices_diff", "mu", "err", - "h_i_mean", "h_i_sigma", "h_sigma"}; + "h_i_mean", "h_i_sigma", "h_sigma", "means_ordered"}; names__.reserve(names__.size() + temp.size()); names__.insert(names__.end(), temp.begin(), temp.end()); } @@ -3039,7 +3065,8 @@ class constraints_model final : public model_base_crtp { std::vector{static_cast(Nr)}, std::vector{static_cast(Nr)}, std::vector{static_cast(Nr)}, - std::vector{static_cast(Nr)}}; + std::vector{static_cast(Nr)}, + std::vector{static_cast(N)}}; dimss__.reserve(dimss__.size() + temp.size()); dimss__.insert(dimss__.end(), temp.begin(), temp.end()); } @@ -3161,6 +3188,10 @@ class constraints_model final : public model_base_crtp { param_names__.emplace_back(std::string() + "h_sigma" + '.' + std::to_string(sym1__)); } + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + param_names__.emplace_back(std::string() + "means_ordered" + '.' + + std::to_string(sym1__)); + } } if (emit_generated_quantities__) {} } @@ -3273,14 +3304,18 @@ class constraints_model final : public model_base_crtp { param_names__.emplace_back(std::string() + "h_sigma" + '.' + std::to_string(sym1__)); } + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + param_names__.emplace_back(std::string() + "means_ordered" + '.' + + std::to_string(sym1__)); + } } if (emit_generated_quantities__) {} } inline std::string get_constrained_sizedtypes() const { - return std::string("[{\"name\":\"high_low_est\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"h\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"parameters\"},{\"name\":\"ar\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(2) + "},\"block\":\"parameters\"},{\"name\":\"ma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi_beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"Intercept\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"sigma_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"row_vec_lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"offset_mult_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"unit_vec_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"pos_ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"corr_matrix_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"cov_matrix_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_cov_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(K) + ",\"cols\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_corr_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(K) + ",\"cols\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"prices\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"},{\"name\":\"prices_diff\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"mu\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"err\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_mean\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"}]"); + return std::string("[{\"name\":\"high_low_est\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"h\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"parameters\"},{\"name\":\"ar\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(2) + "},\"block\":\"parameters\"},{\"name\":\"ma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi_beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"Intercept\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"sigma_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"row_vec_lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"offset_mult_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"unit_vec_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"pos_ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"corr_matrix_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"cov_matrix_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_cov_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(K) + ",\"cols\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_corr_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(K) + ",\"cols\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"prices\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"},{\"name\":\"prices_diff\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"mu\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"err\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_mean\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"means_ordered\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"}]"); } inline std::string get_unconstrained_sizedtypes() const { - return std::string("[{\"name\":\"high_low_est\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"h\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"parameters\"},{\"name\":\"ar\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(2) + "},\"block\":\"parameters\"},{\"name\":\"ma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi_beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"Intercept\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"sigma_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"row_vec_lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"offset_mult_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"unit_vec_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"pos_ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"corr_matrix_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(((N * (N - 1)) /2)) + "},\"block\":\"parameters\"},{\"name\":\"cov_matrix_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string((N + ((N * (N - 1)) /2))) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_cov_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(((((K * (K - 1)) / 2) + K) + ((K - K) *K))) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_corr_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(((K * (K - 1)) /2)) + "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"prices\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"},{\"name\":\"prices_diff\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"mu\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"err\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_mean\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"}]"); + return std::string("[{\"name\":\"high_low_est\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"h\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"parameters\"},{\"name\":\"ar\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(2) + "},\"block\":\"parameters\"},{\"name\":\"ma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi_beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"Intercept\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"sigma_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"row_vec_lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"offset_mult_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"unit_vec_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"pos_ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"corr_matrix_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(((N * (N - 1)) /2)) + "},\"block\":\"parameters\"},{\"name\":\"cov_matrix_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string((N + ((N * (N - 1)) /2))) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_cov_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(((((K * (K - 1)) / 2) + K) + ((K - K) *K))) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_corr_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(((K * (K - 1)) /2)) + "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"prices\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"},{\"name\":\"prices_diff\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"mu\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"err\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_mean\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"means_ordered\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"}]"); } // Begin method overload boilerplate template inline void @@ -3292,8 +3327,8 @@ class constraints_model final : public model_base_crtp { const size_t num_params__ = (((((((((((((((((((((N + K) + Nr) + 2) + 1) + 1) + 1) + 1) + N) + N) + 1) + N) + N) + N) + N) + N) + N) + N) + (N * N)) + (N * N)) + (K * K)) + (K * K)); - const size_t num_transformed = emit_transformed_parameters * (((((((((1 + - 1) + N) + Nr) + Nr) + Nr) + Nr) + Nr) + Nr)); + const size_t num_transformed = emit_transformed_parameters * ((((((((((1 + + 1) + N) + Nr) + Nr) + Nr) + Nr) + Nr) + Nr) + N)); const size_t num_gen_quantities = emit_generated_quantities * (0); const size_t num_to_write = num_params__ + num_transformed + num_gen_quantities; @@ -3312,8 +3347,8 @@ class constraints_model final : public model_base_crtp { const size_t num_params__ = (((((((((((((((((((((N + K) + Nr) + 2) + 1) + 1) + 1) + 1) + N) + N) + 1) + N) + N) + N) + N) + N) + N) + N) + (N * N)) + (N * N)) + (K * K)) + (K * K)); - const size_t num_transformed = emit_transformed_parameters * (((((((((1 + - 1) + N) + Nr) + Nr) + Nr) + Nr) + Nr) + Nr)); + const size_t num_transformed = emit_transformed_parameters * ((((((((((1 + + 1) + N) + Nr) + Nr) + Nr) + Nr) + Nr) + Nr) + N)); const size_t num_gen_quantities = emit_generated_quantities * (0); const size_t num_to_write = num_params__ + num_transformed + num_gen_quantities; diff --git a/test/integration/good/compiler-optimizations/mem_patterns/transformed_mir.expected b/test/integration/good/compiler-optimizations/mem_patterns/transformed_mir.expected index afcec8010b..12187c62bb 100644 --- a/test/integration/good/compiler-optimizations/mem_patterns/transformed_mir.expected +++ b/test/integration/good/compiler-optimizations/mem_patterns/transformed_mir.expected @@ -2061,6 +2061,7 @@ vector[Nr] err: SoA vector[Nr] h_i_mean: SoA vector[Nr] h_i_sigma: SoA vector[Nr] h_sigma: SoA +vector[N] means_ordered: SoA ((functions_block ()) (input_vars ((N @@ -2891,6 +2892,13 @@ vector[Nr] h_sigma: SoA (meta ((type_ UInt) (loc ) (adlevel DataOnly)))) ((pattern (Lit Str Nr)) (meta ((type_ UInt) (loc ) (adlevel DataOnly)))) ((pattern (Var Nr)) (meta ((type_ UInt) (loc ) (adlevel DataOnly))))))) + (meta )) + ((pattern + (NRFunApp (CompilerInternal FnValidateSize) + (((pattern (Lit Str means_ordered)) + (meta ((type_ UInt) (loc ) (adlevel DataOnly)))) + ((pattern (Lit Str N)) (meta ((type_ UInt) (loc ) (adlevel DataOnly)))) + ((pattern (Var N)) (meta ((type_ UInt) (loc ) (adlevel DataOnly))))))) (meta )))) (log_prob (((pattern @@ -3862,6 +3870,22 @@ vector[Nr] h_sigma: SoA (meta ((type_ UReal) (loc ) (adlevel DataOnly))))))) (meta ((type_ UVector) (loc ) (adlevel AutoDiffable)))))) (meta )) + ((pattern + (Decl (decl_adtype AutoDiffable) (decl_id means_ordered) + (decl_type + (Sized + (SVector AoS + ((pattern (Var N)) (meta ((type_ UInt) (loc ) (adlevel DataOnly))))))) + (initialize Default))) + (meta )) + ((pattern + (Assignment ((LVariable means_ordered) ()) UVector + ((pattern + (FunApp (StanLib ordered_jacobian FnJacobian AoS) + (((pattern (Var mean_price)) + (meta ((type_ UVector) (loc ) (adlevel AutoDiffable))))))) + (meta ((type_ UVector) (loc ) (adlevel AutoDiffable)))))) + (meta )) ((pattern (NRFunApp (CompilerInternal @@ -5057,6 +5081,22 @@ vector[Nr] h_sigma: SoA (meta ((type_ UReal) (loc ) (adlevel DataOnly))))))) (meta ((type_ UVector) (loc ) (adlevel AutoDiffable)))))) (meta )) + ((pattern + (Decl (decl_adtype AutoDiffable) (decl_id means_ordered) + (decl_type + (Sized + (SVector SoA + ((pattern (Var N)) (meta ((type_ UInt) (loc ) (adlevel DataOnly))))))) + (initialize Default))) + (meta )) + ((pattern + (Assignment ((LVariable means_ordered) ()) UVector + ((pattern + (FunApp (StanLib ordered_jacobian FnJacobian SoA) + (((pattern (Var mean_price)) + (meta ((type_ UVector) (loc ) (adlevel AutoDiffable))))))) + (meta ((type_ UVector) (loc ) (adlevel AutoDiffable)))))) + (meta )) ((pattern (NRFunApp (CompilerInternal @@ -5891,6 +5931,14 @@ vector[Nr] h_sigma: SoA ((pattern (Var Nr)) (meta ((type_ UInt) (loc ) (adlevel DataOnly))))))) (initialize Default))) (meta )) + ((pattern + (Decl (decl_adtype DataOnly) (decl_id means_ordered) + (decl_type + (Sized + (SVector AoS + ((pattern (Var N)) (meta ((type_ UInt) (loc ) (adlevel DataOnly))))))) + (initialize Default))) + (meta )) ((pattern (NRFunApp (CompilerInternal @@ -6459,6 +6507,14 @@ vector[Nr] h_sigma: SoA (meta ((type_ UReal) (loc ) (adlevel DataOnly))))))) (meta ((type_ UVector) (loc ) (adlevel AutoDiffable)))))) (meta )) + ((pattern + (Assignment ((LVariable means_ordered) ()) UVector + ((pattern + (FunApp (StanLib ordered_jacobian FnJacobian AoS) + (((pattern (Var mean_price)) + (meta ((type_ UVector) (loc ) (adlevel AutoDiffable))))))) + (meta ((type_ UVector) (loc ) (adlevel AutoDiffable)))))) + (meta )) ((pattern (NRFunApp (CompilerInternal @@ -6602,6 +6658,15 @@ vector[Nr] h_sigma: SoA ((pattern (Var h_sigma)) (meta ((type_ UVector) (loc ) (adlevel DataOnly))))))) ())) + (meta )) + ((pattern + (NRFunApp + (CompilerInternal + (FnWriteParam (unconstrain_opt ()) + (var + ((pattern (Var means_ordered)) + (meta ((type_ UVector) (loc ) (adlevel DataOnly))))))) + ())) (meta ))))) (meta )) ())) @@ -9169,6 +9234,18 @@ vector[Nr] h_sigma: SoA (out_constrained_st (SVector AoS ((pattern (Var Nr)) (meta ((type_ UInt) (loc ) (adlevel DataOnly)))))) + (out_block TransformedParameters) (out_trans Identity))) + (means_ordered + ((begin_loc + ((filename constraints.stan) (line_num 69) (col_num 2) (included_from ()))) + (end_loc + ((filename constraints.stan) (line_num 69) (col_num 57) (included_from ())))) + ((out_unconstrained_st + (SVector AoS + ((pattern (Var N)) (meta ((type_ UInt) (loc ) (adlevel DataOnly)))))) + (out_constrained_st + (SVector AoS + ((pattern (Var N)) (meta ((type_ UInt) (loc ) (adlevel DataOnly)))))) (out_block TransformedParameters) (out_trans Identity))))) (prog_name constraints_model) (prog_path constraints.stan)) [exit 0] diff --git a/test/integration/good/function-signatures/math/transforms/cholesky_factor_corr_constrain.stan b/test/integration/good/function-signatures/math/transforms/cholesky_factor_corr_constrain.stan new file mode 100644 index 0000000000..8f0e87a727 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/cholesky_factor_corr_constrain.stan @@ -0,0 +1,60 @@ +data { + int d_int; + vector[choose(d_int,2)] d_vector; + array[d_int] vector[choose(d_int,2)] d_vector_array_1d; + array[d_int, 2] vector[choose(d_int,2)] d_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] d_vector_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int, d_int] td_matrix; + vector[choose(d_int,2)] td_vector; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int] vector[choose(d_int,2)] td_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2] vector[choose(d_int,2)] td_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2, 3] vector[choose(d_int,2)] td_vector_array_3d; + + td_matrix = cholesky_factor_corr_constrain(d_vector, d_int); + td_matrix_array_1d = cholesky_factor_corr_constrain(d_vector_array_1d, d_int); + td_matrix_array_2d = cholesky_factor_corr_constrain(d_vector_array_2d, d_int); + td_matrix_array_3d = cholesky_factor_corr_constrain(d_vector_array_3d, d_int); +} + +parameters { + matrix[d_int, d_int] p_matrix; + vector[choose(d_int,2)] p_vector; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int] vector[choose(d_int,2)] p_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2] vector[choose(d_int,2)] p_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] vector[choose(d_int,2)] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int,2)] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] vector[choose(d_int,2)] transformed_param_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] vector[choose(d_int,2)] transformed_param_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] vector[choose(d_int,2)] transformed_param_vector_array_3d; + + transformed_param_matrix = cholesky_factor_corr_constrain(d_vector, d_int); + transformed_param_matrix = cholesky_factor_corr_constrain(p_vector, d_int); + transformed_param_matrix_array_1d = cholesky_factor_corr_constrain(d_vector_array_1d, d_int); + transformed_param_matrix_array_1d = cholesky_factor_corr_constrain(p_vector_array_1d, d_int); + transformed_param_matrix_array_2d = cholesky_factor_corr_constrain(d_vector_array_2d, d_int); + transformed_param_matrix_array_2d = cholesky_factor_corr_constrain(p_vector_array_2d, d_int); + transformed_param_matrix_array_3d = cholesky_factor_corr_constrain(d_vector_array_3d, d_int); + transformed_param_matrix_array_3d = cholesky_factor_corr_constrain(p_vector_array_3d, d_int); +} + diff --git a/test/integration/good/function-signatures/math/transforms/cholesky_factor_corr_jacobian.stan b/test/integration/good/function-signatures/math/transforms/cholesky_factor_corr_jacobian.stan new file mode 100644 index 0000000000..90cb5b77cc --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/cholesky_factor_corr_jacobian.stan @@ -0,0 +1,39 @@ +data { + int d_int; + vector[choose(d_int,2)] d_vector; + array[d_int] vector[choose(d_int,2)] d_vector_array_1d; + array[d_int, 2] vector[choose(d_int,2)] d_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] d_vector_array_3d; + + +} + +parameters { + vector[choose(d_int,2)] p_vector; + array[d_int] vector[choose(d_int,2)] p_vector_array_1d; + array[d_int, 2] vector[choose(d_int,2)] p_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int,2)] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] vector[choose(d_int,2)] transformed_param_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] vector[choose(d_int,2)] transformed_param_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] vector[choose(d_int,2)] transformed_param_vector_array_3d; + + transformed_param_matrix = cholesky_factor_corr_jacobian(d_vector, d_int); + transformed_param_matrix = cholesky_factor_corr_jacobian(p_vector, d_int); + transformed_param_matrix_array_1d = cholesky_factor_corr_jacobian(d_vector_array_1d, d_int); + transformed_param_matrix_array_1d = cholesky_factor_corr_jacobian(p_vector_array_1d, d_int); + transformed_param_matrix_array_2d = cholesky_factor_corr_jacobian(d_vector_array_2d, d_int); + transformed_param_matrix_array_2d = cholesky_factor_corr_jacobian(p_vector_array_2d, d_int); + transformed_param_matrix_array_3d = cholesky_factor_corr_jacobian(d_vector_array_3d, d_int); + transformed_param_matrix_array_3d = cholesky_factor_corr_jacobian(p_vector_array_3d, d_int); +} + diff --git a/test/integration/good/function-signatures/math/transforms/cholesky_factor_corr_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/cholesky_factor_corr_unconstrain.stan new file mode 100644 index 0000000000..a173346a7a --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/cholesky_factor_corr_unconstrain.stan @@ -0,0 +1,60 @@ +data { + int d_int; + matrix[d_int, d_int] d_matrix; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int, d_int] td_matrix; + vector[choose(d_int, 2)] td_vector; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int] vector[choose(d_int, 2)] td_vector_array_1d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2] vector[choose(d_int, 2)] td_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2)] td_vector_array_3d; + + td_vector = cholesky_factor_corr_unconstrain(d_matrix); + td_vector_array_1d = cholesky_factor_corr_unconstrain(d_matrix_array_1d); + td_vector_array_2d = cholesky_factor_corr_unconstrain(d_matrix_array_2d); + td_vector_array_3d = cholesky_factor_corr_unconstrain(d_matrix_array_3d); +} + +parameters { + matrix[d_int, d_int] p_matrix; + vector[choose(d_int, 2)] p_vector; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int] vector[choose(d_int, 2)] p_vector_array_1d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2] vector[choose(d_int, 2)] p_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2)] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int, 2)] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int] vector[choose(d_int, 2)] transformed_param_vector_array_1d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2] vector[choose(d_int, 2)] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2)] transformed_param_vector_array_3d; + + transformed_param_vector = cholesky_factor_corr_unconstrain(d_matrix); + transformed_param_vector = cholesky_factor_corr_unconstrain(p_matrix); + transformed_param_vector_array_1d = cholesky_factor_corr_unconstrain(d_matrix_array_1d); + transformed_param_vector_array_1d = cholesky_factor_corr_unconstrain(p_matrix_array_1d); + transformed_param_vector_array_2d = cholesky_factor_corr_unconstrain(d_matrix_array_2d); + transformed_param_vector_array_2d = cholesky_factor_corr_unconstrain(p_matrix_array_2d); + transformed_param_vector_array_3d = cholesky_factor_corr_unconstrain(d_matrix_array_3d); + transformed_param_vector_array_3d = cholesky_factor_corr_unconstrain(p_matrix_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/cholesky_factor_cov_constrain.stan b/test/integration/good/function-signatures/math/transforms/cholesky_factor_cov_constrain.stan new file mode 100644 index 0000000000..dbffb01e32 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/cholesky_factor_cov_constrain.stan @@ -0,0 +1,60 @@ +data { + int d_int; + vector[choose(d_int, 2) + d_int] d_vector; + array[d_int] vector[choose(d_int, 2) + d_int] d_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] d_vector_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int, d_int] td_matrix; + vector[choose(d_int, 2) + d_int] td_vector; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int] vector[choose(d_int, 2) + d_int] td_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] td_vector_array_3d; + + td_matrix = cholesky_factor_cov_constrain(d_vector, d_int, d_int); + td_matrix_array_1d = cholesky_factor_cov_constrain(d_vector_array_1d, d_int, d_int); + td_matrix_array_2d = cholesky_factor_cov_constrain(d_vector_array_2d, d_int, d_int); + td_matrix_array_3d = cholesky_factor_cov_constrain(d_vector_array_3d, d_int, d_int); +} + +parameters { + matrix[d_int, d_int] p_matrix; + vector[choose(d_int, 2) + d_int] p_vector; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int] vector[choose(d_int, 2) + d_int] p_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int, 2) + d_int] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_3d; + + transformed_param_matrix = cholesky_factor_cov_constrain(d_vector, d_int, d_int); + transformed_param_matrix = cholesky_factor_cov_constrain(p_vector, d_int, d_int); + transformed_param_matrix_array_1d = cholesky_factor_cov_constrain(d_vector_array_1d, d_int, d_int); + transformed_param_matrix_array_1d = cholesky_factor_cov_constrain(p_vector_array_1d, d_int, d_int); + transformed_param_matrix_array_2d = cholesky_factor_cov_constrain(d_vector_array_2d, d_int, d_int); + transformed_param_matrix_array_2d = cholesky_factor_cov_constrain(p_vector_array_2d, d_int, d_int); + transformed_param_matrix_array_3d = cholesky_factor_cov_constrain(d_vector_array_3d, d_int, d_int); + transformed_param_matrix_array_3d = cholesky_factor_cov_constrain(p_vector_array_3d, d_int, d_int); +} + diff --git a/test/integration/good/function-signatures/math/transforms/cholesky_factor_cov_jacobian.stan b/test/integration/good/function-signatures/math/transforms/cholesky_factor_cov_jacobian.stan new file mode 100644 index 0000000000..420ac50e37 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/cholesky_factor_cov_jacobian.stan @@ -0,0 +1,39 @@ +data { + int d_int; + vector[choose(d_int, 2) + d_int] d_vector; + array[d_int] vector[choose(d_int, 2) + d_int] d_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] d_vector_array_3d; + + +} + +parameters { + vector[choose(d_int, 2) + d_int] p_vector; + array[d_int] vector[choose(d_int, 2) + d_int] p_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int, 2) + d_int] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_3d; + + transformed_param_matrix = cholesky_factor_cov_jacobian(d_vector, d_int, d_int); + transformed_param_matrix = cholesky_factor_cov_jacobian(p_vector, d_int, d_int); + transformed_param_matrix_array_1d = cholesky_factor_cov_jacobian(d_vector_array_1d, d_int, d_int); + transformed_param_matrix_array_1d = cholesky_factor_cov_jacobian(p_vector_array_1d, d_int, d_int); + transformed_param_matrix_array_2d = cholesky_factor_cov_jacobian(d_vector_array_2d, d_int, d_int); + transformed_param_matrix_array_2d = cholesky_factor_cov_jacobian(p_vector_array_2d, d_int, d_int); + transformed_param_matrix_array_3d = cholesky_factor_cov_jacobian(d_vector_array_3d, d_int, d_int); + transformed_param_matrix_array_3d = cholesky_factor_cov_jacobian(p_vector_array_3d, d_int, d_int); +} + diff --git a/test/integration/good/function-signatures/math/transforms/cholesky_factor_cov_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/cholesky_factor_cov_unconstrain.stan new file mode 100644 index 0000000000..8bdfc6561f --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/cholesky_factor_cov_unconstrain.stan @@ -0,0 +1,60 @@ +data { + int d_int; + matrix[d_int, d_int] d_matrix; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int, d_int] td_matrix; + vector[choose(d_int, 2) + d_int] td_vector; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int] vector[choose(d_int, 2) + d_int] td_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] td_vector_array_3d; + + td_vector = cholesky_factor_cov_unconstrain(d_matrix); + td_vector_array_1d = cholesky_factor_cov_unconstrain(d_matrix_array_1d); + td_vector_array_2d = cholesky_factor_cov_unconstrain(d_matrix_array_2d); + td_vector_array_3d = cholesky_factor_cov_unconstrain(d_matrix_array_3d); +} + +parameters { + matrix[d_int, d_int] p_matrix; + vector[choose(d_int, 2) + d_int] p_vector; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int] vector[choose(d_int, 2) + d_int] p_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int, 2) + d_int] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_3d; + + transformed_param_vector = cholesky_factor_cov_unconstrain(d_matrix); + transformed_param_vector = cholesky_factor_cov_unconstrain(p_matrix); + transformed_param_vector_array_1d = cholesky_factor_cov_unconstrain(d_matrix_array_1d); + transformed_param_vector_array_1d = cholesky_factor_cov_unconstrain(p_matrix_array_1d); + transformed_param_vector_array_2d = cholesky_factor_cov_unconstrain(d_matrix_array_2d); + transformed_param_vector_array_2d = cholesky_factor_cov_unconstrain(p_matrix_array_2d); + transformed_param_vector_array_3d = cholesky_factor_cov_unconstrain(d_matrix_array_3d); + transformed_param_vector_array_3d = cholesky_factor_cov_unconstrain(p_matrix_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/corr_matrix_constrain.stan b/test/integration/good/function-signatures/math/transforms/corr_matrix_constrain.stan new file mode 100644 index 0000000000..f5721db66d --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/corr_matrix_constrain.stan @@ -0,0 +1,60 @@ +data { + int d_int; + vector[choose(d_int,2)] d_vector; + array[d_int] vector[choose(d_int,2)] d_vector_array_1d; + array[d_int, 2] vector[choose(d_int,2)] d_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] d_vector_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int, d_int] td_matrix; + vector[choose(d_int,2)] td_vector; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int] vector[choose(d_int,2)] td_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2] vector[choose(d_int,2)] td_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] td_vector_array_3d; + + td_matrix = corr_matrix_constrain(d_vector, d_int); + td_matrix_array_1d = corr_matrix_constrain(d_vector_array_1d, d_int); + td_matrix_array_2d = corr_matrix_constrain(d_vector_array_2d, d_int); + td_matrix_array_3d = corr_matrix_constrain(d_vector_array_3d, d_int); +} + +parameters { + matrix[d_int, d_int] p_matrix; + vector[choose(d_int,2)] p_vector; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int] vector[choose(d_int,2)] p_vector_array_1d; + array[d_int, 2] vector[choose(d_int,2)] p_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] vector[choose(d_int,2)] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int,2)] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int] vector[choose(d_int,2)] transformed_param_vector_array_1d; + array[d_int, 2] vector[choose(d_int,2)] transformed_param_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] vector[choose(d_int,2)] transformed_param_vector_array_3d; + + transformed_param_matrix = corr_matrix_constrain(d_vector, d_int); + transformed_param_matrix = corr_matrix_constrain(p_vector, d_int); + transformed_param_matrix_array_1d = corr_matrix_constrain(d_vector_array_1d, d_int); + transformed_param_matrix_array_1d = corr_matrix_constrain(p_vector_array_1d, d_int); + transformed_param_matrix_array_2d = corr_matrix_constrain(d_vector_array_2d, d_int); + transformed_param_matrix_array_2d = corr_matrix_constrain(p_vector_array_2d, d_int); + transformed_param_matrix_array_3d = corr_matrix_constrain(d_vector_array_3d, d_int); + transformed_param_matrix_array_3d = corr_matrix_constrain(p_vector_array_3d, d_int); +} + diff --git a/test/integration/good/function-signatures/math/transforms/corr_matrix_jacobian.stan b/test/integration/good/function-signatures/math/transforms/corr_matrix_jacobian.stan new file mode 100644 index 0000000000..91492b0d2c --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/corr_matrix_jacobian.stan @@ -0,0 +1,39 @@ +data { + int d_int; + vector[choose(d_int,2)] d_vector; + array[d_int] vector[choose(d_int,2)] d_vector_array_1d; + array[d_int, 2] vector[choose(d_int,2)] d_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] d_vector_array_3d; + + +} + +parameters { + vector[choose(d_int,2)] p_vector; + array[d_int] vector[choose(d_int,2)] p_vector_array_1d; + array[d_int, 2] vector[choose(d_int,2)] p_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int,2)] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] vector[choose(d_int,2)] transformed_param_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2] vector[choose(d_int,2)] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] transformed_param_vector_array_3d; + + transformed_param_matrix = corr_matrix_jacobian(d_vector, d_int); + transformed_param_matrix = corr_matrix_jacobian(p_vector, d_int); + transformed_param_matrix_array_1d = corr_matrix_jacobian(d_vector_array_1d, d_int); + transformed_param_matrix_array_1d = corr_matrix_jacobian(p_vector_array_1d, d_int); + transformed_param_matrix_array_2d = corr_matrix_jacobian(d_vector_array_2d, d_int); + transformed_param_matrix_array_2d = corr_matrix_jacobian(p_vector_array_2d, d_int); + transformed_param_matrix_array_3d = corr_matrix_jacobian(d_vector_array_3d, d_int); + transformed_param_matrix_array_3d = corr_matrix_jacobian(p_vector_array_3d, d_int); +} + diff --git a/test/integration/good/function-signatures/math/transforms/corr_matrix_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/corr_matrix_unconstrain.stan new file mode 100644 index 0000000000..8f998c2bfe --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/corr_matrix_unconstrain.stan @@ -0,0 +1,60 @@ +data { + int d_int; + matrix[d_int, d_int] d_matrix; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int, d_int] td_matrix; + vector[choose(d_int, 2)] td_vector; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int] vector[choose(d_int, 2)] td_vector_array_1d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2] vector[choose(d_int, 2)] td_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2)] td_vector_array_3d; + + td_vector = corr_matrix_unconstrain(d_matrix); + td_vector_array_1d = corr_matrix_unconstrain(d_matrix_array_1d); + td_vector_array_2d = corr_matrix_unconstrain(d_matrix_array_2d); + td_vector_array_3d = corr_matrix_unconstrain(d_matrix_array_3d); +} + +parameters { + matrix[d_int, d_int] p_matrix; + vector[choose(d_int, 2)] p_vector; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int] vector[choose(d_int, 2)] p_vector_array_1d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2] vector[choose(d_int, 2)] p_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2)] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int, 2)] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int] vector[choose(d_int, 2)] transformed_param_vector_array_1d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2] vector[choose(d_int, 2)] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2)] transformed_param_vector_array_3d; + + transformed_param_vector = corr_matrix_unconstrain(d_matrix); + transformed_param_vector = corr_matrix_unconstrain(p_matrix); + transformed_param_vector_array_1d = corr_matrix_unconstrain(d_matrix_array_1d); + transformed_param_vector_array_1d = corr_matrix_unconstrain(p_matrix_array_1d); + transformed_param_vector_array_2d = corr_matrix_unconstrain(d_matrix_array_2d); + transformed_param_vector_array_2d = corr_matrix_unconstrain(p_matrix_array_2d); + transformed_param_vector_array_3d = corr_matrix_unconstrain(d_matrix_array_3d); + transformed_param_vector_array_3d = corr_matrix_unconstrain(p_matrix_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/cov_matrix_constrain.stan b/test/integration/good/function-signatures/math/transforms/cov_matrix_constrain.stan new file mode 100644 index 0000000000..c743ca4a18 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/cov_matrix_constrain.stan @@ -0,0 +1,60 @@ +data { + int d_int; + vector[choose(d_int,2)] d_vector; + array[d_int] vector[choose(d_int,2)] d_vector_array_1d; + array[d_int, 2] vector[choose(d_int,2)] d_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] d_vector_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int, d_int] td_matrix; + vector[choose(d_int,2)] td_vector; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int] vector[choose(d_int,2)] td_vector_array_1d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2] vector[choose(d_int,2)] td_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] td_vector_array_3d; + + td_matrix = cov_matrix_constrain(d_vector, d_int); + td_matrix_array_1d = cov_matrix_constrain(d_vector_array_1d, d_int); + td_matrix_array_2d = cov_matrix_constrain(d_vector_array_2d, d_int); + td_matrix_array_3d = cov_matrix_constrain(d_vector_array_3d, d_int); +} + +parameters { + matrix[d_int, d_int] p_matrix; + vector[choose(d_int,2)] p_vector; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int] vector[choose(d_int,2)] p_vector_array_1d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2] vector[choose(d_int,2)] p_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int,2)] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int] vector[choose(d_int,2)] transformed_param_vector_array_1d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2] vector[choose(d_int,2)] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] transformed_param_vector_array_3d; + + transformed_param_matrix = cov_matrix_constrain(d_vector, d_int); + transformed_param_matrix = cov_matrix_constrain(p_vector, d_int); + transformed_param_matrix_array_1d = cov_matrix_constrain(d_vector_array_1d, d_int); + transformed_param_matrix_array_1d = cov_matrix_constrain(p_vector_array_1d, d_int); + transformed_param_matrix_array_2d = cov_matrix_constrain(d_vector_array_2d, d_int); + transformed_param_matrix_array_2d = cov_matrix_constrain(p_vector_array_2d, d_int); + transformed_param_matrix_array_3d = cov_matrix_constrain(d_vector_array_3d, d_int); + transformed_param_matrix_array_3d = cov_matrix_constrain(p_vector_array_3d, d_int); +} + diff --git a/test/integration/good/function-signatures/math/transforms/cov_matrix_jacobian.stan b/test/integration/good/function-signatures/math/transforms/cov_matrix_jacobian.stan new file mode 100644 index 0000000000..c595b8c021 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/cov_matrix_jacobian.stan @@ -0,0 +1,39 @@ +data { + int d_int; + vector[choose(d_int,2)] d_vector; + array[d_int] vector[choose(d_int,2)] d_vector_array_1d; + array[d_int, 2] vector[choose(d_int,2)] d_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] d_vector_array_3d; + + +} + +parameters { + vector[choose(d_int,2)] p_vector; + array[d_int] vector[choose(d_int,2)] p_vector_array_1d; + array[d_int, 2] vector[choose(d_int,2)] p_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int,2)] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] vector[choose(d_int,2)] transformed_param_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2] vector[choose(d_int,2)] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int,2)] transformed_param_vector_array_3d; + + transformed_param_matrix = cov_matrix_jacobian(d_vector, d_int); + transformed_param_matrix = cov_matrix_jacobian(p_vector, d_int); + transformed_param_matrix_array_1d = cov_matrix_jacobian(d_vector_array_1d, d_int); + transformed_param_matrix_array_1d = cov_matrix_jacobian(p_vector_array_1d, d_int); + transformed_param_matrix_array_2d = cov_matrix_jacobian(d_vector_array_2d, d_int); + transformed_param_matrix_array_2d = cov_matrix_jacobian(p_vector_array_2d, d_int); + transformed_param_matrix_array_3d = cov_matrix_jacobian(d_vector_array_3d, d_int); + transformed_param_matrix_array_3d = cov_matrix_jacobian(p_vector_array_3d, d_int); +} + diff --git a/test/integration/good/function-signatures/math/transforms/cov_matrix_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/cov_matrix_unconstrain.stan new file mode 100644 index 0000000000..18423266e8 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/cov_matrix_unconstrain.stan @@ -0,0 +1,60 @@ +data { + int d_int; + matrix[d_int, d_int] d_matrix; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int, d_int] td_matrix; + vector[choose(d_int, 2) + d_int] td_vector; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int] vector[choose(d_int, 2) + d_int] td_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] td_vector_array_3d; + + td_vector = cov_matrix_unconstrain(d_matrix); + td_vector_array_1d = cov_matrix_unconstrain(d_matrix_array_1d); + td_vector_array_2d = cov_matrix_unconstrain(d_matrix_array_2d); + td_vector_array_3d = cov_matrix_unconstrain(d_matrix_array_3d); +} + +parameters { + matrix[d_int, d_int] p_matrix; + vector[choose(d_int, 2) + d_int] p_vector; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int] vector[choose(d_int, 2) + d_int] p_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] p_vector_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + vector[choose(d_int, 2) + d_int] transformed_param_vector; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[choose(d_int, 2) + d_int] transformed_param_vector_array_3d; + + transformed_param_vector = cov_matrix_unconstrain(d_matrix); + transformed_param_vector = cov_matrix_unconstrain(p_matrix); + transformed_param_vector_array_1d = cov_matrix_unconstrain(d_matrix_array_1d); + transformed_param_vector_array_1d = cov_matrix_unconstrain(p_matrix_array_1d); + transformed_param_vector_array_2d = cov_matrix_unconstrain(d_matrix_array_2d); + transformed_param_vector_array_2d = cov_matrix_unconstrain(p_matrix_array_2d); + transformed_param_vector_array_3d = cov_matrix_unconstrain(d_matrix_array_3d); + transformed_param_vector_array_3d = cov_matrix_unconstrain(p_matrix_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/lower_bound_constrain.stan b/test/integration/good/function-signatures/math/transforms/lower_bound_constrain.stan new file mode 100644 index 0000000000..3c90ba2043 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/lower_bound_constrain.stan @@ -0,0 +1,239 @@ +data { + int d_int; + real d_real; + vector[d_int] d_vector; + matrix[d_int, d_int] d_matrix; + row_vector[d_int] d_row_vector; + array[d_int] real d_real_array_1d; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int] row_vector[d_int] d_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; + + +} + +transformed data { + int td_int; + real td_real; + vector[d_int] td_vector; + matrix[d_int, d_int] td_matrix; + row_vector[d_int] td_row_vector; + array[d_int] real td_real_array_1d; + array[d_int, 2] real td_real_array_2d; + array[d_int, 2, 3] real td_real_array_3d; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int] row_vector[d_int] td_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2] row_vector[d_int] td_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] td_row_vector_array_3d; + + td_matrix = lower_bound_constrain(d_matrix, d_matrix); + td_matrix = lower_bound_constrain(d_matrix, d_real); + td_matrix_array_1d = lower_bound_constrain(d_matrix_array_1d, d_matrix_array_1d); + td_matrix_array_1d = lower_bound_constrain(d_matrix_array_1d, d_real); + td_matrix_array_2d = lower_bound_constrain(d_matrix_array_2d, d_matrix_array_2d); + td_matrix_array_2d = lower_bound_constrain(d_matrix_array_2d, d_real); + td_matrix_array_3d = lower_bound_constrain(d_matrix_array_3d, d_matrix_array_3d); + td_matrix_array_3d = lower_bound_constrain(d_matrix_array_3d, d_real); + td_real = lower_bound_constrain(d_real, d_real); + td_real_array_1d = lower_bound_constrain(d_real_array_1d, d_real); + td_real_array_1d = lower_bound_constrain(d_real_array_1d, d_real_array_1d); + td_real_array_2d = lower_bound_constrain(d_real_array_2d, d_real); + td_real_array_2d = lower_bound_constrain(d_real_array_2d, d_real_array_2d); + td_real_array_3d = lower_bound_constrain(d_real_array_3d, d_real); + td_real_array_3d = lower_bound_constrain(d_real_array_3d, d_real_array_3d); + td_row_vector = lower_bound_constrain(d_row_vector, d_real); + td_row_vector = lower_bound_constrain(d_row_vector, d_row_vector); + td_row_vector_array_1d = lower_bound_constrain(d_row_vector_array_1d, d_real); + td_row_vector_array_1d = lower_bound_constrain(d_row_vector_array_1d, d_row_vector_array_1d); + td_row_vector_array_2d = lower_bound_constrain(d_row_vector_array_2d, d_real); + td_row_vector_array_2d = lower_bound_constrain(d_row_vector_array_2d, d_row_vector_array_2d); + td_row_vector_array_3d = lower_bound_constrain(d_row_vector_array_3d, d_real); + td_row_vector_array_3d = lower_bound_constrain(d_row_vector_array_3d, d_row_vector_array_3d); + td_vector = lower_bound_constrain(d_vector, d_real); + td_vector = lower_bound_constrain(d_vector, d_vector); + td_vector_array_1d = lower_bound_constrain(d_vector_array_1d, d_real); + td_vector_array_1d = lower_bound_constrain(d_vector_array_1d, d_vector_array_1d); + td_vector_array_2d = lower_bound_constrain(d_vector_array_2d, d_real); + td_vector_array_2d = lower_bound_constrain(d_vector_array_2d, d_vector_array_2d); + td_vector_array_3d = lower_bound_constrain(d_vector_array_3d, d_real); + td_vector_array_3d = lower_bound_constrain(d_vector_array_3d, d_vector_array_3d); +} + +parameters { + real p_real; + vector[d_int] p_vector; + matrix[d_int, d_int] p_matrix; + row_vector[d_int] p_row_vector; + array[d_int] real p_real_array_1d; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int] row_vector[d_int] p_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + + +} + +transformed parameters { + real transformed_param_real; + vector[d_int] transformed_param_vector; + matrix[d_int, d_int] transformed_param_matrix; + row_vector[d_int] transformed_param_row_vector; + array[d_int] real transformed_param_real_array_1d; + array[d_int, 2] real transformed_param_real_array_2d; + array[d_int, 2, 3] real transformed_param_real_array_3d; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] row_vector[d_int] transformed_param_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_param_matrix = lower_bound_constrain(d_matrix, d_matrix); + transformed_param_matrix = lower_bound_constrain(d_matrix, d_real); + transformed_param_matrix = lower_bound_constrain(d_matrix, p_matrix); + transformed_param_matrix = lower_bound_constrain(d_matrix, p_real); + transformed_param_matrix = lower_bound_constrain(p_matrix, d_matrix); + transformed_param_matrix = lower_bound_constrain(p_matrix, d_real); + transformed_param_matrix = lower_bound_constrain(p_matrix, p_matrix); + transformed_param_matrix = lower_bound_constrain(p_matrix, p_real); + transformed_param_matrix_array_1d = lower_bound_constrain(d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_bound_constrain(d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_bound_constrain(d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_bound_constrain(d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = lower_bound_constrain(p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_bound_constrain(p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_bound_constrain(p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_bound_constrain(p_matrix_array_1d, p_real); + transformed_param_matrix_array_2d = lower_bound_constrain(d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_bound_constrain(d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_bound_constrain(d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_bound_constrain(d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = lower_bound_constrain(p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_bound_constrain(p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_bound_constrain(p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_bound_constrain(p_matrix_array_2d, p_real); + transformed_param_matrix_array_3d = lower_bound_constrain(d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_bound_constrain(d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_bound_constrain(d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_bound_constrain(d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_bound_constrain(p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_bound_constrain(p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_bound_constrain(p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_bound_constrain(p_matrix_array_3d, p_real); + transformed_param_real = lower_bound_constrain(d_real, d_real); + transformed_param_real = lower_bound_constrain(d_real, p_real); + transformed_param_real = lower_bound_constrain(p_real, d_real); + transformed_param_real = lower_bound_constrain(p_real, p_real); + transformed_param_real_array_1d = lower_bound_constrain(d_real_array_1d, d_real); + transformed_param_real_array_1d = lower_bound_constrain(d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_bound_constrain(d_real_array_1d, p_real); + transformed_param_real_array_1d = lower_bound_constrain(d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = lower_bound_constrain(p_real_array_1d, d_real); + transformed_param_real_array_1d = lower_bound_constrain(p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_bound_constrain(p_real_array_1d, p_real); + transformed_param_real_array_1d = lower_bound_constrain(p_real_array_1d, p_real_array_1d); + transformed_param_real_array_2d = lower_bound_constrain(d_real_array_2d, d_real); + transformed_param_real_array_2d = lower_bound_constrain(d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_bound_constrain(d_real_array_2d, p_real); + transformed_param_real_array_2d = lower_bound_constrain(d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = lower_bound_constrain(p_real_array_2d, d_real); + transformed_param_real_array_2d = lower_bound_constrain(p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_bound_constrain(p_real_array_2d, p_real); + transformed_param_real_array_2d = lower_bound_constrain(p_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = lower_bound_constrain(d_real_array_3d, d_real); + transformed_param_real_array_3d = lower_bound_constrain(d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_bound_constrain(d_real_array_3d, p_real); + transformed_param_real_array_3d = lower_bound_constrain(d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = lower_bound_constrain(p_real_array_3d, d_real); + transformed_param_real_array_3d = lower_bound_constrain(p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_bound_constrain(p_real_array_3d, p_real); + transformed_param_real_array_3d = lower_bound_constrain(p_real_array_3d, p_real_array_3d); + transformed_param_row_vector = lower_bound_constrain(d_row_vector, d_real); + transformed_param_row_vector = lower_bound_constrain(d_row_vector, d_row_vector); + transformed_param_row_vector = lower_bound_constrain(d_row_vector, p_real); + transformed_param_row_vector = lower_bound_constrain(d_row_vector, p_row_vector); + transformed_param_row_vector = lower_bound_constrain(p_row_vector, d_real); + transformed_param_row_vector = lower_bound_constrain(p_row_vector, d_row_vector); + transformed_param_row_vector = lower_bound_constrain(p_row_vector, p_real); + transformed_param_row_vector = lower_bound_constrain(p_row_vector, p_row_vector); + transformed_param_row_vector_array_1d = lower_bound_constrain(d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_bound_constrain(d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_bound_constrain(d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_bound_constrain(d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_bound_constrain(p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_bound_constrain(p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_bound_constrain(p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_bound_constrain(p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = lower_bound_constrain(d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_bound_constrain(d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_bound_constrain(d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_bound_constrain(d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_bound_constrain(p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_bound_constrain(p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_bound_constrain(p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_bound_constrain(p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_bound_constrain(d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_bound_constrain(d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_bound_constrain(d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_bound_constrain(d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_bound_constrain(p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_bound_constrain(p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_bound_constrain(p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_bound_constrain(p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_vector = lower_bound_constrain(d_vector, d_real); + transformed_param_vector = lower_bound_constrain(d_vector, d_vector); + transformed_param_vector = lower_bound_constrain(d_vector, p_real); + transformed_param_vector = lower_bound_constrain(d_vector, p_vector); + transformed_param_vector = lower_bound_constrain(p_vector, d_real); + transformed_param_vector = lower_bound_constrain(p_vector, d_vector); + transformed_param_vector = lower_bound_constrain(p_vector, p_real); + transformed_param_vector = lower_bound_constrain(p_vector, p_vector); + transformed_param_vector_array_1d = lower_bound_constrain(d_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_bound_constrain(d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_bound_constrain(d_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_bound_constrain(d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = lower_bound_constrain(p_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_bound_constrain(p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_bound_constrain(p_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_bound_constrain(p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_2d = lower_bound_constrain(d_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_bound_constrain(d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_bound_constrain(d_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_bound_constrain(d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = lower_bound_constrain(p_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_bound_constrain(p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_bound_constrain(p_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_bound_constrain(p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_3d = lower_bound_constrain(d_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_bound_constrain(d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_bound_constrain(d_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_bound_constrain(d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = lower_bound_constrain(p_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_bound_constrain(p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_bound_constrain(p_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_bound_constrain(p_vector_array_3d, p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/lower_bound_jacobian.stan b/test/integration/good/function-signatures/math/transforms/lower_bound_jacobian.stan new file mode 100644 index 0000000000..dc22d44ac5 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/lower_bound_jacobian.stan @@ -0,0 +1,198 @@ +data { + int d_int; + array[d_int] int d_int_array; + array[d_int, 2] int d_int_array_2d; + array[d_int, 2, 3] int d_int_array_3d; + real d_real; + array[d_int] real d_real_array; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + matrix[d_int, d_int] d_matrix; + array[d_int] matrix[d_int, d_int] d_matrix_array; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + row_vector[d_int] d_row_vector; + array[d_int] row_vector[d_int] d_row_vector_array; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; +} + +parameters { + real p_real; + array[d_int] real p_real_array; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + matrix[d_int, d_int] p_matrix; + array[d_int] matrix[d_int, d_int] p_matrix_array; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + row_vector[d_int] p_row_vector; + array[d_int] row_vector[d_int] p_row_vector_array; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + real y_p; +} +transformed parameters { + real transformed_real; + array[d_int] real transformed_param_array; + array[d_int, 2] real transformed_param_array_2d; + array[d_int, 2, 3] real transformed_param_array_3d; + matrix[d_int, d_int] transformed_param_matrix; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + row_vector[d_int] transformed_param_row_vector; + array[d_int] row_vector[d_int] transformed_param_row_vector_array; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_real = lower_bound_jacobian(d_real, d_real); + transformed_real = lower_bound_jacobian(d_real, p_real); + transformed_real = lower_bound_jacobian(p_real, d_real); + transformed_real = lower_bound_jacobian(p_real, p_real); + + transformed_param_array_2d = lower_bound_jacobian(p_real_array_2d, d_real); + transformed_param_array_2d = lower_bound_jacobian(p_real_array_2d, p_real); + transformed_param_array_2d = lower_bound_jacobian(d_real_array_2d, p_real); + transformed_param_array_2d = lower_bound_jacobian(d_real_array_2d, d_real); + transformed_param_array_3d = lower_bound_jacobian(d_real_array_3d, d_real); + transformed_param_array_3d = lower_bound_jacobian(p_real_array_3d, d_real); + transformed_param_array_3d = lower_bound_jacobian(p_real_array_3d, p_real); + transformed_param_array_3d = lower_bound_jacobian(d_real_array_3d, p_real); + + + transformed_param_array = lower_bound_jacobian(d_real_array, d_real_array); + transformed_param_array = lower_bound_jacobian(d_real_array, p_real_array); + transformed_param_array = lower_bound_jacobian(p_real_array, d_real_array); + transformed_param_array = lower_bound_jacobian(p_real_array, p_real_array); + transformed_param_array_2d = lower_bound_jacobian(d_real_array_2d, p_real_array_2d); + transformed_param_array_2d = lower_bound_jacobian(p_real_array_2d, d_real_array_2d); + transformed_param_array_2d = lower_bound_jacobian(p_real_array_2d, p_real_array_2d); + transformed_param_array_3d = lower_bound_jacobian(d_real_array_3d, p_real_array_3d); + transformed_param_array_3d = lower_bound_jacobian(p_real_array_3d, d_real_array_3d); + transformed_param_array_3d = lower_bound_jacobian(p_real_array_3d, p_real_array_3d); + + transformed_param_vector = lower_bound_jacobian(p_vector, p_real); + transformed_param_vector = lower_bound_jacobian(p_vector, d_real); + transformed_param_vector = lower_bound_jacobian(d_vector, p_real); + transformed_param_vector_array = lower_bound_jacobian(p_vector_array, p_real); + transformed_param_vector_array = lower_bound_jacobian(p_vector_array, d_real); + transformed_param_vector_array = lower_bound_jacobian(d_vector_array, p_real); + transformed_param_vector_array_2d = lower_bound_jacobian(p_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_bound_jacobian(p_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_bound_jacobian(d_vector_array_2d, p_real); + transformed_param_vector_array_3d = lower_bound_jacobian(p_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_bound_jacobian(p_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_bound_jacobian(d_vector_array_3d, p_real); + + transformed_param_vector = lower_bound_jacobian(p_vector, p_vector); + transformed_param_vector = lower_bound_jacobian(p_vector, d_vector); + transformed_param_vector = lower_bound_jacobian(d_vector, p_vector); + transformed_param_vector_array = lower_bound_jacobian(p_vector_array, p_vector_array); + transformed_param_vector_array = lower_bound_jacobian(p_vector_array, d_vector_array); + transformed_param_vector_array = lower_bound_jacobian(d_vector_array, p_vector_array); + transformed_param_vector_array_2d = lower_bound_jacobian(p_vector_array_2d, + p_vector_array_2d); + transformed_param_vector_array_2d = lower_bound_jacobian(p_vector_array_2d, + d_vector_array_2d); + transformed_param_vector_array_2d = lower_bound_jacobian(d_vector_array_2d, + p_vector_array_2d); + transformed_param_vector_array_3d = lower_bound_jacobian(p_vector_array_3d, + p_vector_array_3d); + transformed_param_vector_array_3d = lower_bound_jacobian(p_vector_array_3d, + d_vector_array_3d); + transformed_param_vector_array_3d = lower_bound_jacobian(d_vector_array_3d, + p_vector_array_3d); + + transformed_param_row_vector = lower_bound_jacobian(p_row_vector, p_real); + transformed_param_row_vector = lower_bound_jacobian(p_row_vector, d_real); + transformed_param_row_vector = lower_bound_jacobian(d_row_vector, p_real); + transformed_param_row_vector_array = lower_bound_jacobian(p_row_vector_array, p_real); + transformed_param_row_vector_array = lower_bound_jacobian(p_row_vector_array, d_real); + transformed_param_row_vector_array = lower_bound_jacobian(d_row_vector_array, p_real); + transformed_param_row_vector_array_2d = lower_bound_jacobian(p_row_vector_array_2d, + p_real); + transformed_param_row_vector_array_2d = lower_bound_jacobian(p_row_vector_array_2d, + d_real); + transformed_param_row_vector_array_2d = lower_bound_jacobian(d_row_vector_array_2d, + p_real); + transformed_param_row_vector_array_3d = lower_bound_jacobian(p_row_vector_array_3d, + p_real); + transformed_param_row_vector_array_3d = lower_bound_jacobian(p_row_vector_array_3d, + d_real); + transformed_param_row_vector_array_3d = lower_bound_jacobian(d_row_vector_array_3d, + p_real); + + + + transformed_param_row_vector = lower_bound_jacobian(p_row_vector, p_row_vector); + transformed_param_row_vector = lower_bound_jacobian(p_row_vector, d_row_vector); + transformed_param_row_vector = lower_bound_jacobian(d_row_vector, p_row_vector); + transformed_param_row_vector_array = lower_bound_jacobian(p_row_vector_array, + p_row_vector_array); + transformed_param_row_vector_array = lower_bound_jacobian(p_row_vector_array, + d_row_vector_array); + transformed_param_row_vector_array = lower_bound_jacobian(d_row_vector_array, + p_row_vector_array); + transformed_param_row_vector_array_2d = lower_bound_jacobian(p_row_vector_array_2d, + p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_bound_jacobian(p_row_vector_array_2d, + d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_bound_jacobian(d_row_vector_array_2d, + p_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_bound_jacobian(p_row_vector_array_3d, + p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_bound_jacobian(p_row_vector_array_3d, + d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_bound_jacobian(d_row_vector_array_3d, + p_row_vector_array_3d); + + transformed_param_matrix = lower_bound_jacobian(p_matrix, p_real); + transformed_param_matrix = lower_bound_jacobian(p_matrix, d_real); + transformed_param_matrix = lower_bound_jacobian(d_matrix, p_real); + transformed_param_matrix_array = lower_bound_jacobian(p_matrix_array, p_real); + transformed_param_matrix_array = lower_bound_jacobian(p_matrix_array, d_real); + transformed_param_matrix_array = lower_bound_jacobian(d_matrix_array, p_real); + transformed_param_matrix_array_2d = lower_bound_jacobian(p_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = lower_bound_jacobian(p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_bound_jacobian(d_matrix_array_2d, p_real); + transformed_param_matrix_array_3d = lower_bound_jacobian(p_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_bound_jacobian(p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_bound_jacobian(d_matrix_array_3d, p_real); + + + transformed_param_matrix = lower_bound_jacobian(p_matrix, p_matrix); + transformed_param_matrix = lower_bound_jacobian(p_matrix, d_matrix); + transformed_param_matrix = lower_bound_jacobian(d_matrix, p_matrix); + transformed_param_matrix_array = lower_bound_jacobian(p_matrix_array, p_matrix_array); + transformed_param_matrix_array = lower_bound_jacobian(p_matrix_array, d_matrix_array); + transformed_param_matrix_array = lower_bound_jacobian(d_matrix_array, p_matrix_array); + transformed_param_matrix_array_2d = lower_bound_jacobian(p_matrix_array_2d, + p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_bound_jacobian(p_matrix_array_2d, + d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_bound_jacobian(d_matrix_array_2d, + p_matrix_array_2d); + transformed_param_matrix_array_3d = lower_bound_jacobian(p_matrix_array_3d, + p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_bound_jacobian(p_matrix_array_3d, + d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_bound_jacobian(d_matrix_array_3d, + p_matrix_array_3d); +} +model { + y_p ~ normal(0, 1); +} + diff --git a/test/integration/good/function-signatures/math/transforms/lower_bound_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/lower_bound_unconstrain.stan new file mode 100644 index 0000000000..eb327fc1a8 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/lower_bound_unconstrain.stan @@ -0,0 +1,239 @@ +data { + int d_int; + real d_real; + vector[d_int] d_vector; + matrix[d_int, d_int] d_matrix; + row_vector[d_int] d_row_vector; + array[d_int] real d_real_array_1d; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int] row_vector[d_int] d_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; + + +} + +transformed data { + int td_int; + real td_real; + vector[d_int] td_vector; + matrix[d_int, d_int] td_matrix; + row_vector[d_int] td_row_vector; + array[d_int] real td_real_array_1d; + array[d_int, 2] real td_real_array_2d; + array[d_int, 2, 3] real td_real_array_3d; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int] row_vector[d_int] td_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2] row_vector[d_int] td_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] td_row_vector_array_3d; + + td_matrix = lower_bound_unconstrain(d_matrix, d_matrix); + td_matrix = lower_bound_unconstrain(d_matrix, d_real); + td_matrix_array_1d = lower_bound_unconstrain(d_matrix_array_1d, d_matrix_array_1d); + td_matrix_array_1d = lower_bound_unconstrain(d_matrix_array_1d, d_real); + td_matrix_array_2d = lower_bound_unconstrain(d_matrix_array_2d, d_matrix_array_2d); + td_matrix_array_2d = lower_bound_unconstrain(d_matrix_array_2d, d_real); + td_matrix_array_3d = lower_bound_unconstrain(d_matrix_array_3d, d_matrix_array_3d); + td_matrix_array_3d = lower_bound_unconstrain(d_matrix_array_3d, d_real); + td_real = lower_bound_unconstrain(d_real, d_real); + td_real_array_1d = lower_bound_unconstrain(d_real_array_1d, d_real); + td_real_array_1d = lower_bound_unconstrain(d_real_array_1d, d_real_array_1d); + td_real_array_2d = lower_bound_unconstrain(d_real_array_2d, d_real); + td_real_array_2d = lower_bound_unconstrain(d_real_array_2d, d_real_array_2d); + td_real_array_3d = lower_bound_unconstrain(d_real_array_3d, d_real); + td_real_array_3d = lower_bound_unconstrain(d_real_array_3d, d_real_array_3d); + td_row_vector = lower_bound_unconstrain(d_row_vector, d_real); + td_row_vector = lower_bound_unconstrain(d_row_vector, d_row_vector); + td_row_vector_array_1d = lower_bound_unconstrain(d_row_vector_array_1d, d_real); + td_row_vector_array_1d = lower_bound_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d); + td_row_vector_array_2d = lower_bound_unconstrain(d_row_vector_array_2d, d_real); + td_row_vector_array_2d = lower_bound_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d); + td_row_vector_array_3d = lower_bound_unconstrain(d_row_vector_array_3d, d_real); + td_row_vector_array_3d = lower_bound_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d); + td_vector = lower_bound_unconstrain(d_vector, d_real); + td_vector = lower_bound_unconstrain(d_vector, d_vector); + td_vector_array_1d = lower_bound_unconstrain(d_vector_array_1d, d_real); + td_vector_array_1d = lower_bound_unconstrain(d_vector_array_1d, d_vector_array_1d); + td_vector_array_2d = lower_bound_unconstrain(d_vector_array_2d, d_real); + td_vector_array_2d = lower_bound_unconstrain(d_vector_array_2d, d_vector_array_2d); + td_vector_array_3d = lower_bound_unconstrain(d_vector_array_3d, d_real); + td_vector_array_3d = lower_bound_unconstrain(d_vector_array_3d, d_vector_array_3d); +} + +parameters { + real p_real; + vector[d_int] p_vector; + matrix[d_int, d_int] p_matrix; + row_vector[d_int] p_row_vector; + array[d_int] real p_real_array_1d; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int] row_vector[d_int] p_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + + +} + +transformed parameters { + real transformed_param_real; + vector[d_int] transformed_param_vector; + matrix[d_int, d_int] transformed_param_matrix; + row_vector[d_int] transformed_param_row_vector; + array[d_int] real transformed_param_real_array_1d; + array[d_int, 2] real transformed_param_real_array_2d; + array[d_int, 2, 3] real transformed_param_real_array_3d; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] row_vector[d_int] transformed_param_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_param_matrix = lower_bound_unconstrain(d_matrix, d_matrix); + transformed_param_matrix = lower_bound_unconstrain(d_matrix, d_real); + transformed_param_matrix = lower_bound_unconstrain(d_matrix, p_matrix); + transformed_param_matrix = lower_bound_unconstrain(d_matrix, p_real); + transformed_param_matrix = lower_bound_unconstrain(p_matrix, d_matrix); + transformed_param_matrix = lower_bound_unconstrain(p_matrix, d_real); + transformed_param_matrix = lower_bound_unconstrain(p_matrix, p_matrix); + transformed_param_matrix = lower_bound_unconstrain(p_matrix, p_real); + transformed_param_matrix_array_1d = lower_bound_unconstrain(d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_bound_unconstrain(d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_bound_unconstrain(d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_bound_unconstrain(d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = lower_bound_unconstrain(p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_bound_unconstrain(p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_bound_unconstrain(p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_bound_unconstrain(p_matrix_array_1d, p_real); + transformed_param_matrix_array_2d = lower_bound_unconstrain(d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_bound_unconstrain(d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_bound_unconstrain(d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_bound_unconstrain(d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = lower_bound_unconstrain(p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_bound_unconstrain(p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_bound_unconstrain(p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_bound_unconstrain(p_matrix_array_2d, p_real); + transformed_param_matrix_array_3d = lower_bound_unconstrain(d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_bound_unconstrain(d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_bound_unconstrain(d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_bound_unconstrain(d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_bound_unconstrain(p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_bound_unconstrain(p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_bound_unconstrain(p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_bound_unconstrain(p_matrix_array_3d, p_real); + transformed_param_real = lower_bound_unconstrain(d_real, d_real); + transformed_param_real = lower_bound_unconstrain(d_real, p_real); + transformed_param_real = lower_bound_unconstrain(p_real, d_real); + transformed_param_real = lower_bound_unconstrain(p_real, p_real); + transformed_param_real_array_1d = lower_bound_unconstrain(d_real_array_1d, d_real); + transformed_param_real_array_1d = lower_bound_unconstrain(d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_bound_unconstrain(d_real_array_1d, p_real); + transformed_param_real_array_1d = lower_bound_unconstrain(d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = lower_bound_unconstrain(p_real_array_1d, d_real); + transformed_param_real_array_1d = lower_bound_unconstrain(p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_bound_unconstrain(p_real_array_1d, p_real); + transformed_param_real_array_1d = lower_bound_unconstrain(p_real_array_1d, p_real_array_1d); + transformed_param_real_array_2d = lower_bound_unconstrain(d_real_array_2d, d_real); + transformed_param_real_array_2d = lower_bound_unconstrain(d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_bound_unconstrain(d_real_array_2d, p_real); + transformed_param_real_array_2d = lower_bound_unconstrain(d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = lower_bound_unconstrain(p_real_array_2d, d_real); + transformed_param_real_array_2d = lower_bound_unconstrain(p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_bound_unconstrain(p_real_array_2d, p_real); + transformed_param_real_array_2d = lower_bound_unconstrain(p_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = lower_bound_unconstrain(d_real_array_3d, d_real); + transformed_param_real_array_3d = lower_bound_unconstrain(d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_bound_unconstrain(d_real_array_3d, p_real); + transformed_param_real_array_3d = lower_bound_unconstrain(d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = lower_bound_unconstrain(p_real_array_3d, d_real); + transformed_param_real_array_3d = lower_bound_unconstrain(p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_bound_unconstrain(p_real_array_3d, p_real); + transformed_param_real_array_3d = lower_bound_unconstrain(p_real_array_3d, p_real_array_3d); + transformed_param_row_vector = lower_bound_unconstrain(d_row_vector, d_real); + transformed_param_row_vector = lower_bound_unconstrain(d_row_vector, d_row_vector); + transformed_param_row_vector = lower_bound_unconstrain(d_row_vector, p_real); + transformed_param_row_vector = lower_bound_unconstrain(d_row_vector, p_row_vector); + transformed_param_row_vector = lower_bound_unconstrain(p_row_vector, d_real); + transformed_param_row_vector = lower_bound_unconstrain(p_row_vector, d_row_vector); + transformed_param_row_vector = lower_bound_unconstrain(p_row_vector, p_real); + transformed_param_row_vector = lower_bound_unconstrain(p_row_vector, p_row_vector); + transformed_param_row_vector_array_1d = lower_bound_unconstrain(d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_bound_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_bound_unconstrain(d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_bound_unconstrain(d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_bound_unconstrain(p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_bound_unconstrain(p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_bound_unconstrain(p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_bound_unconstrain(p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = lower_bound_unconstrain(d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_bound_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_bound_unconstrain(d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_bound_unconstrain(d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_bound_unconstrain(p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_bound_unconstrain(p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_bound_unconstrain(p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_bound_unconstrain(p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_bound_unconstrain(d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_bound_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_bound_unconstrain(d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_bound_unconstrain(d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_bound_unconstrain(p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_bound_unconstrain(p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_bound_unconstrain(p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_bound_unconstrain(p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_vector = lower_bound_unconstrain(d_vector, d_real); + transformed_param_vector = lower_bound_unconstrain(d_vector, d_vector); + transformed_param_vector = lower_bound_unconstrain(d_vector, p_real); + transformed_param_vector = lower_bound_unconstrain(d_vector, p_vector); + transformed_param_vector = lower_bound_unconstrain(p_vector, d_real); + transformed_param_vector = lower_bound_unconstrain(p_vector, d_vector); + transformed_param_vector = lower_bound_unconstrain(p_vector, p_real); + transformed_param_vector = lower_bound_unconstrain(p_vector, p_vector); + transformed_param_vector_array_1d = lower_bound_unconstrain(d_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_bound_unconstrain(d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_bound_unconstrain(d_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_bound_unconstrain(d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = lower_bound_unconstrain(p_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_bound_unconstrain(p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_bound_unconstrain(p_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_bound_unconstrain(p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_2d = lower_bound_unconstrain(d_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_bound_unconstrain(d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_bound_unconstrain(d_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_bound_unconstrain(d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = lower_bound_unconstrain(p_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_bound_unconstrain(p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_bound_unconstrain(p_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_bound_unconstrain(p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_3d = lower_bound_unconstrain(d_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_bound_unconstrain(d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_bound_unconstrain(d_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_bound_unconstrain(d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = lower_bound_unconstrain(p_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_bound_unconstrain(p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_bound_unconstrain(p_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_bound_unconstrain(p_vector_array_3d, p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/lower_upper_bound_constrain.stan b/test/integration/good/function-signatures/math/transforms/lower_upper_bound_constrain.stan new file mode 100644 index 0000000000..31780c6e57 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/lower_upper_bound_constrain.stan @@ -0,0 +1,498 @@ +data { + int d_int; + real d_real; + vector[d_int] d_vector; + matrix[d_int, d_int] d_matrix; + row_vector[d_int] d_row_vector; + array[d_int] real d_real_array_1d; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int] row_vector[d_int] d_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; + + +} + +transformed data { + int td_int; + real td_real; + vector[d_int] td_vector; + matrix[d_int, d_int] td_matrix; + row_vector[d_int] td_row_vector; + array[d_int] real td_real_array_1d; + array[d_int, 2] real td_real_array_2d; + array[d_int, 2, 3] real td_real_array_3d; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int] row_vector[d_int] td_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2] row_vector[d_int] td_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] td_row_vector_array_3d; + + td_matrix = lower_upper_bound_constrain(d_matrix, d_matrix, d_matrix); + td_matrix = lower_upper_bound_constrain(d_matrix, d_matrix, d_real); + td_matrix = lower_upper_bound_constrain(d_matrix, d_real, d_matrix); + td_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + td_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, d_matrix_array_1d, d_real); + td_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, d_real, d_matrix_array_1d); + td_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + td_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, d_matrix_array_2d, d_real); + td_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, d_real, d_matrix_array_2d); + td_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + td_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, d_matrix_array_3d, d_real); + td_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, d_real, d_matrix_array_3d); + td_real = lower_upper_bound_constrain(d_real, d_real, d_real); + td_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, d_real, d_real_array_1d); + td_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, d_real_array_1d, d_real); + td_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, d_real_array_1d, d_real_array_1d); + td_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, d_real, d_real_array_2d); + td_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, d_real_array_2d, d_real); + td_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, d_real_array_2d, d_real_array_2d); + td_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, d_real, d_real_array_3d); + td_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, d_real_array_3d, d_real); + td_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, d_real_array_3d, d_real_array_3d); + td_row_vector = lower_upper_bound_constrain(d_row_vector, d_real, d_row_vector); + td_row_vector = lower_upper_bound_constrain(d_row_vector, d_row_vector, d_real); + td_row_vector = lower_upper_bound_constrain(d_row_vector, d_row_vector, d_row_vector); + td_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, d_real, d_row_vector_array_1d); + td_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, d_row_vector_array_1d, d_real); + td_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + td_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, d_real, d_row_vector_array_2d); + td_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, d_row_vector_array_2d, d_real); + td_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + td_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, d_real, d_row_vector_array_3d); + td_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, d_row_vector_array_3d, d_real); + td_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + td_vector = lower_upper_bound_constrain(d_vector, d_real, d_vector); + td_vector = lower_upper_bound_constrain(d_vector, d_vector, d_real); + td_vector = lower_upper_bound_constrain(d_vector, d_vector, d_vector); + td_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, d_real, d_vector_array_1d); + td_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, d_vector_array_1d, d_real); + td_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + td_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, d_real, d_vector_array_2d); + td_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, d_vector_array_2d, d_real); + td_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + td_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, d_real, d_vector_array_3d); + td_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, d_vector_array_3d, d_real); + td_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, d_vector_array_3d, d_vector_array_3d); +} + +parameters { + real p_real; + vector[d_int] p_vector; + matrix[d_int, d_int] p_matrix; + row_vector[d_int] p_row_vector; + array[d_int] real p_real_array_1d; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int] row_vector[d_int] p_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + + +} + +transformed parameters { + real transformed_param_real; + vector[d_int] transformed_param_vector; + matrix[d_int, d_int] transformed_param_matrix; + row_vector[d_int] transformed_param_row_vector; + array[d_int] real transformed_param_real_array_1d; + array[d_int, 2] real transformed_param_real_array_2d; + array[d_int, 2, 3] real transformed_param_real_array_3d; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] row_vector[d_int] transformed_param_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, d_matrix, d_matrix); + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, d_matrix, d_real); + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, d_matrix, p_matrix); + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, d_matrix, p_real); + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, d_real, d_matrix); + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, d_real, p_matrix); + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, p_matrix, d_matrix); + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, p_matrix, d_real); + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, p_matrix, p_matrix); + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, p_matrix, p_real); + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, p_real, d_matrix); + transformed_param_matrix = lower_upper_bound_constrain(d_matrix, p_real, p_matrix); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, d_matrix, d_matrix); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, d_matrix, d_real); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, d_matrix, p_matrix); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, d_matrix, p_real); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, d_real, d_matrix); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, d_real, p_matrix); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, p_matrix, d_matrix); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, p_matrix, d_real); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, p_matrix, p_matrix); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, p_matrix, p_real); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, p_real, d_matrix); + transformed_param_matrix = lower_upper_bound_constrain(p_matrix, p_real, p_matrix); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(d_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_constrain(p_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(d_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_constrain(p_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(d_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_constrain(p_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_real = lower_upper_bound_constrain(d_real, d_real, d_real); + transformed_param_real = lower_upper_bound_constrain(d_real, d_real, p_real); + transformed_param_real = lower_upper_bound_constrain(d_real, p_real, d_real); + transformed_param_real = lower_upper_bound_constrain(d_real, p_real, p_real); + transformed_param_real = lower_upper_bound_constrain(p_real, d_real, d_real); + transformed_param_real = lower_upper_bound_constrain(p_real, d_real, p_real); + transformed_param_real = lower_upper_bound_constrain(p_real, p_real, d_real); + transformed_param_real = lower_upper_bound_constrain(p_real, p_real, p_real); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, d_real, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, d_real, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_1d = lower_upper_bound_constrain(d_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, d_real, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, d_real, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_1d = lower_upper_bound_constrain(p_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_2d = lower_upper_bound_constrain(d_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_2d = lower_upper_bound_constrain(p_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_3d = lower_upper_bound_constrain(d_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_3d = lower_upper_bound_constrain(p_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, d_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, d_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, d_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, d_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, d_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, p_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, p_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, p_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, p_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_constrain(d_row_vector, p_row_vector, p_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, d_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, d_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, d_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, d_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, d_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, p_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, p_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, p_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, p_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_constrain(p_row_vector, p_row_vector, p_row_vector); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(d_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_upper_bound_constrain(p_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(d_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_constrain(p_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(d_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_constrain(p_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_vector = lower_upper_bound_constrain(d_vector, d_real, d_vector); + transformed_param_vector = lower_upper_bound_constrain(d_vector, d_real, p_vector); + transformed_param_vector = lower_upper_bound_constrain(d_vector, d_vector, d_real); + transformed_param_vector = lower_upper_bound_constrain(d_vector, d_vector, d_vector); + transformed_param_vector = lower_upper_bound_constrain(d_vector, d_vector, p_real); + transformed_param_vector = lower_upper_bound_constrain(d_vector, d_vector, p_vector); + transformed_param_vector = lower_upper_bound_constrain(d_vector, p_real, d_vector); + transformed_param_vector = lower_upper_bound_constrain(d_vector, p_real, p_vector); + transformed_param_vector = lower_upper_bound_constrain(d_vector, p_vector, d_real); + transformed_param_vector = lower_upper_bound_constrain(d_vector, p_vector, d_vector); + transformed_param_vector = lower_upper_bound_constrain(d_vector, p_vector, p_real); + transformed_param_vector = lower_upper_bound_constrain(d_vector, p_vector, p_vector); + transformed_param_vector = lower_upper_bound_constrain(p_vector, d_real, d_vector); + transformed_param_vector = lower_upper_bound_constrain(p_vector, d_real, p_vector); + transformed_param_vector = lower_upper_bound_constrain(p_vector, d_vector, d_real); + transformed_param_vector = lower_upper_bound_constrain(p_vector, d_vector, d_vector); + transformed_param_vector = lower_upper_bound_constrain(p_vector, d_vector, p_real); + transformed_param_vector = lower_upper_bound_constrain(p_vector, d_vector, p_vector); + transformed_param_vector = lower_upper_bound_constrain(p_vector, p_real, d_vector); + transformed_param_vector = lower_upper_bound_constrain(p_vector, p_real, p_vector); + transformed_param_vector = lower_upper_bound_constrain(p_vector, p_vector, d_real); + transformed_param_vector = lower_upper_bound_constrain(p_vector, p_vector, d_vector); + transformed_param_vector = lower_upper_bound_constrain(p_vector, p_vector, p_real); + transformed_param_vector = lower_upper_bound_constrain(p_vector, p_vector, p_vector); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_constrain(d_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_constrain(p_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_constrain(d_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_constrain(p_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_upper_bound_constrain(d_vector_array_3d, p_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_upper_bound_constrain(p_vector_array_3d, p_vector_array_3d, p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/lower_upper_bound_jacobian.stan b/test/integration/good/function-signatures/math/transforms/lower_upper_bound_jacobian.stan new file mode 100644 index 0000000000..40a55983ee --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/lower_upper_bound_jacobian.stan @@ -0,0 +1,431 @@ +data { + int d_int; + real d_real; + vector[d_int] d_vector; + matrix[d_int, d_int] d_matrix; + row_vector[d_int] d_row_vector; + array[d_int] real d_real_array_1d; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int] row_vector[d_int] d_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; + + +} + +parameters { + real p_real; + vector[d_int] p_vector; + matrix[d_int, d_int] p_matrix; + row_vector[d_int] p_row_vector; + array[d_int] real p_real_array_1d; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int] row_vector[d_int] p_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + + +} + +transformed parameters { + real transformed_param_real; + vector[d_int] transformed_param_vector; + matrix[d_int, d_int] transformed_param_matrix; + row_vector[d_int] transformed_param_row_vector; + array[d_int] real transformed_param_real_array_1d; + array[d_int, 2] real transformed_param_real_array_2d; + array[d_int, 2, 3] real transformed_param_real_array_3d; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] row_vector[d_int] transformed_param_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_param_real = lower_upper_bound_jacobian(p_real, p_real, d_real); + transformed_param_real = lower_upper_bound_jacobian(d_real, p_real, d_real); + transformed_param_real = lower_upper_bound_jacobian(d_real, d_real, d_real); + transformed_param_real = lower_upper_bound_jacobian(p_real, d_real, p_real); + transformed_param_real = lower_upper_bound_jacobian(d_real, p_real, p_real); + transformed_param_real = lower_upper_bound_jacobian(d_real, d_real, p_real); + transformed_param_real = lower_upper_bound_jacobian(p_real, p_real, p_real); + transformed_param_real = lower_upper_bound_jacobian(p_real, d_real, d_real); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, p_vector, p_real); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, p_real, p_vector); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, d_real, d_vector); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, d_real, p_matrix); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, p_vector, d_real); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, d_real, d_matrix); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, d_real, d_matrix); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, d_matrix, d_real); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, d_matrix, d_real); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, p_real, p_matrix); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, p_real, d_matrix); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, p_real, d_vector); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, p_vector, d_real); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, d_matrix, p_real); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, p_real, p_matrix); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, p_vector, p_real); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, d_matrix, p_real); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, p_matrix, d_real); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, d_real, p_matrix); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, d_real, p_vector); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, d_vector, d_real); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, d_vector, p_real); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, p_matrix, p_real); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, p_matrix, d_real); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, d_real, d_vector); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, d_real, p_vector); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, p_real, d_matrix); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, p_real, p_vector); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, p_matrix, p_real); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, d_vector, d_real); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, p_real, d_vector); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, d_vector, p_real); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, d_vector, p_vector); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, d_matrix, d_matrix); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, p_matrix, p_matrix); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, d_matrix, p_matrix); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, p_vector, p_vector); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, p_vector, p_vector); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, d_matrix, d_matrix); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, d_vector, d_vector); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, p_matrix, p_matrix); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, p_vector, d_vector); + transformed_param_matrix = lower_upper_bound_jacobian(d_matrix, p_matrix, d_matrix); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, d_matrix, p_matrix); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, d_vector, d_vector); + transformed_param_vector = lower_upper_bound_jacobian(p_vector, d_vector, p_vector); + transformed_param_vector = lower_upper_bound_jacobian(d_vector, p_vector, d_vector); + transformed_param_matrix = lower_upper_bound_jacobian(p_matrix, p_matrix, d_matrix); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, d_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, d_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, d_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, p_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, d_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, d_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, d_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, p_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, p_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, p_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, p_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, p_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, d_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, d_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, p_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, p_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, d_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, d_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(d_row_vector, p_row_vector, p_row_vector); + transformed_param_row_vector = lower_upper_bound_jacobian(p_row_vector, p_row_vector, p_row_vector); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, d_real, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, d_real, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, d_real, d_real_array_1d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, d_real, p_real_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(p_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(d_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_jacobian(p_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(p_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_jacobian(d_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_2d = lower_upper_bound_jacobian(d_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(d_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, p_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, p_vector_array_3d, p_vector_array_3d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_jacobian(p_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(d_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_3d = lower_upper_bound_jacobian(p_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(p_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(p_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(p_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_jacobian(d_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(p_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_vector_array_1d = lower_upper_bound_jacobian(d_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_matrix_array_2d = lower_upper_bound_jacobian(d_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_3d = lower_upper_bound_jacobian(d_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(d_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(p_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_2d = lower_upper_bound_jacobian(p_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(p_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_1d = lower_upper_bound_jacobian(d_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_jacobian(d_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/lower_upper_bound_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/lower_upper_bound_unconstrain.stan new file mode 100644 index 0000000000..5c1b4f93a7 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/lower_upper_bound_unconstrain.stan @@ -0,0 +1,498 @@ +data { + int d_int; + real d_real; + vector[d_int] d_vector; + matrix[d_int, d_int] d_matrix; + row_vector[d_int] d_row_vector; + array[d_int] real d_real_array_1d; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int] row_vector[d_int] d_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; + + +} + +transformed data { + int td_int; + real td_real; + vector[d_int] td_vector; + matrix[d_int, d_int] td_matrix; + row_vector[d_int] td_row_vector; + array[d_int] real td_real_array_1d; + array[d_int, 2] real td_real_array_2d; + array[d_int, 2, 3] real td_real_array_3d; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int] row_vector[d_int] td_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2] row_vector[d_int] td_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] td_row_vector_array_3d; + + td_matrix = lower_upper_bound_unconstrain(d_matrix, d_matrix, d_matrix); + td_matrix = lower_upper_bound_unconstrain(d_matrix, d_matrix, d_real); + td_matrix = lower_upper_bound_unconstrain(d_matrix, d_real, d_matrix); + td_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + td_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, d_matrix_array_1d, d_real); + td_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, d_real, d_matrix_array_1d); + td_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + td_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, d_matrix_array_2d, d_real); + td_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, d_real, d_matrix_array_2d); + td_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + td_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, d_matrix_array_3d, d_real); + td_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, d_real, d_matrix_array_3d); + td_real = lower_upper_bound_unconstrain(d_real, d_real, d_real); + td_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, d_real, d_real_array_1d); + td_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, d_real_array_1d, d_real); + td_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, d_real_array_1d, d_real_array_1d); + td_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, d_real, d_real_array_2d); + td_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, d_real_array_2d, d_real); + td_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, d_real_array_2d, d_real_array_2d); + td_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, d_real, d_real_array_3d); + td_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, d_real_array_3d, d_real); + td_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, d_real_array_3d, d_real_array_3d); + td_row_vector = lower_upper_bound_unconstrain(d_row_vector, d_real, d_row_vector); + td_row_vector = lower_upper_bound_unconstrain(d_row_vector, d_row_vector, d_real); + td_row_vector = lower_upper_bound_unconstrain(d_row_vector, d_row_vector, d_row_vector); + td_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, d_real, d_row_vector_array_1d); + td_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, d_real); + td_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + td_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, d_real, d_row_vector_array_2d); + td_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, d_real); + td_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + td_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, d_real, d_row_vector_array_3d); + td_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, d_real); + td_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + td_vector = lower_upper_bound_unconstrain(d_vector, d_real, d_vector); + td_vector = lower_upper_bound_unconstrain(d_vector, d_vector, d_real); + td_vector = lower_upper_bound_unconstrain(d_vector, d_vector, d_vector); + td_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, d_real, d_vector_array_1d); + td_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, d_vector_array_1d, d_real); + td_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + td_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, d_real, d_vector_array_2d); + td_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, d_vector_array_2d, d_real); + td_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + td_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, d_real, d_vector_array_3d); + td_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, d_vector_array_3d, d_real); + td_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, d_vector_array_3d, d_vector_array_3d); +} + +parameters { + real p_real; + vector[d_int] p_vector; + matrix[d_int, d_int] p_matrix; + row_vector[d_int] p_row_vector; + array[d_int] real p_real_array_1d; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int] row_vector[d_int] p_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + + +} + +transformed parameters { + real transformed_param_real; + vector[d_int] transformed_param_vector; + matrix[d_int, d_int] transformed_param_matrix; + row_vector[d_int] transformed_param_row_vector; + array[d_int] real transformed_param_real_array_1d; + array[d_int, 2] real transformed_param_real_array_2d; + array[d_int, 2, 3] real transformed_param_real_array_3d; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] row_vector[d_int] transformed_param_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, d_matrix, d_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, d_matrix, d_real); + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, d_matrix, p_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, d_matrix, p_real); + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, d_real, d_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, d_real, p_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, p_matrix, d_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, p_matrix, d_real); + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, p_matrix, p_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, p_matrix, p_real); + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, p_real, d_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(d_matrix, p_real, p_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, d_matrix, d_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, d_matrix, d_real); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, d_matrix, p_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, d_matrix, p_real); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, d_real, d_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, d_real, p_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, p_matrix, d_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, p_matrix, d_real); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, p_matrix, p_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, p_matrix, p_real); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, p_real, d_matrix); + transformed_param_matrix = lower_upper_bound_unconstrain(p_matrix, p_real, p_matrix); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(d_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = lower_upper_bound_unconstrain(p_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(d_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = lower_upper_bound_unconstrain(p_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(d_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = lower_upper_bound_unconstrain(p_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_real = lower_upper_bound_unconstrain(d_real, d_real, d_real); + transformed_param_real = lower_upper_bound_unconstrain(d_real, d_real, p_real); + transformed_param_real = lower_upper_bound_unconstrain(d_real, p_real, d_real); + transformed_param_real = lower_upper_bound_unconstrain(d_real, p_real, p_real); + transformed_param_real = lower_upper_bound_unconstrain(p_real, d_real, d_real); + transformed_param_real = lower_upper_bound_unconstrain(p_real, d_real, p_real); + transformed_param_real = lower_upper_bound_unconstrain(p_real, p_real, d_real); + transformed_param_real = lower_upper_bound_unconstrain(p_real, p_real, p_real); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, d_real, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, d_real, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(d_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, d_real, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, d_real, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_1d = lower_upper_bound_unconstrain(p_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(d_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_2d = lower_upper_bound_unconstrain(p_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(d_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_3d = lower_upper_bound_unconstrain(p_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, d_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, d_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, d_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, d_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, d_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, p_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, p_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, p_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, p_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_unconstrain(d_row_vector, p_row_vector, p_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, d_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, d_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, d_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, d_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, d_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, p_real, d_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, p_real, p_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, p_row_vector, d_real); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, p_row_vector, p_real); + transformed_param_row_vector = lower_upper_bound_unconstrain(p_row_vector, p_row_vector, p_row_vector); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(d_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = lower_upper_bound_unconstrain(p_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(d_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = lower_upper_bound_unconstrain(p_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(d_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = lower_upper_bound_unconstrain(p_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, d_real, d_vector); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, d_real, p_vector); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, d_vector, d_real); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, d_vector, d_vector); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, d_vector, p_real); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, d_vector, p_vector); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, p_real, d_vector); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, p_real, p_vector); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, p_vector, d_real); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, p_vector, d_vector); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, p_vector, p_real); + transformed_param_vector = lower_upper_bound_unconstrain(d_vector, p_vector, p_vector); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, d_real, d_vector); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, d_real, p_vector); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, d_vector, d_real); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, d_vector, d_vector); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, d_vector, p_real); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, d_vector, p_vector); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, p_real, d_vector); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, p_real, p_vector); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, p_vector, d_real); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, p_vector, d_vector); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, p_vector, p_real); + transformed_param_vector = lower_upper_bound_unconstrain(p_vector, p_vector, p_vector); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(d_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_vector_array_1d = lower_upper_bound_unconstrain(p_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(d_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_vector_array_2d = lower_upper_bound_unconstrain(p_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(d_vector_array_3d, p_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_vector_array_3d = lower_upper_bound_unconstrain(p_vector_array_3d, p_vector_array_3d, p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/offset_multiplier_constrain.stan b/test/integration/good/function-signatures/math/transforms/offset_multiplier_constrain.stan new file mode 100644 index 0000000000..5ec71d026f --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/offset_multiplier_constrain.stan @@ -0,0 +1,498 @@ +data { + int d_int; + real d_real; + vector[d_int] d_vector; + matrix[d_int, d_int] d_matrix; + row_vector[d_int] d_row_vector; + array[d_int] real d_real_array_1d; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int] row_vector[d_int] d_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; + + +} + +transformed data { + int td_int; + real td_real; + vector[d_int] td_vector; + matrix[d_int, d_int] td_matrix; + row_vector[d_int] td_row_vector; + array[d_int] real td_real_array_1d; + array[d_int, 2] real td_real_array_2d; + array[d_int, 2, 3] real td_real_array_3d; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int] row_vector[d_int] td_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2] row_vector[d_int] td_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] td_row_vector_array_3d; + + td_matrix = offset_multiplier_constrain(d_matrix, d_matrix, d_matrix); + td_matrix = offset_multiplier_constrain(d_matrix, d_matrix, d_real); + td_matrix = offset_multiplier_constrain(d_matrix, d_real, d_matrix); + td_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + td_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, d_matrix_array_1d, d_real); + td_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, d_real, d_matrix_array_1d); + td_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + td_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, d_matrix_array_2d, d_real); + td_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, d_real, d_matrix_array_2d); + td_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + td_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, d_matrix_array_3d, d_real); + td_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, d_real, d_matrix_array_3d); + td_real = offset_multiplier_constrain(d_real, d_real, d_real); + td_real_array_1d = offset_multiplier_constrain(d_real_array_1d, d_real, d_real_array_1d); + td_real_array_1d = offset_multiplier_constrain(d_real_array_1d, d_real_array_1d, d_real); + td_real_array_1d = offset_multiplier_constrain(d_real_array_1d, d_real_array_1d, d_real_array_1d); + td_real_array_2d = offset_multiplier_constrain(d_real_array_2d, d_real, d_real_array_2d); + td_real_array_2d = offset_multiplier_constrain(d_real_array_2d, d_real_array_2d, d_real); + td_real_array_2d = offset_multiplier_constrain(d_real_array_2d, d_real_array_2d, d_real_array_2d); + td_real_array_3d = offset_multiplier_constrain(d_real_array_3d, d_real, d_real_array_3d); + td_real_array_3d = offset_multiplier_constrain(d_real_array_3d, d_real_array_3d, d_real); + td_real_array_3d = offset_multiplier_constrain(d_real_array_3d, d_real_array_3d, d_real_array_3d); + td_row_vector = offset_multiplier_constrain(d_row_vector, d_real, d_row_vector); + td_row_vector = offset_multiplier_constrain(d_row_vector, d_row_vector, d_real); + td_row_vector = offset_multiplier_constrain(d_row_vector, d_row_vector, d_row_vector); + td_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, d_real, d_row_vector_array_1d); + td_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, d_row_vector_array_1d, d_real); + td_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + td_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, d_real, d_row_vector_array_2d); + td_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, d_row_vector_array_2d, d_real); + td_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + td_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, d_real, d_row_vector_array_3d); + td_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, d_row_vector_array_3d, d_real); + td_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + td_vector = offset_multiplier_constrain(d_vector, d_real, d_vector); + td_vector = offset_multiplier_constrain(d_vector, d_vector, d_real); + td_vector = offset_multiplier_constrain(d_vector, d_vector, d_vector); + td_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, d_real, d_vector_array_1d); + td_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, d_vector_array_1d, d_real); + td_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + td_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, d_real, d_vector_array_2d); + td_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, d_vector_array_2d, d_real); + td_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + td_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, d_real, d_vector_array_3d); + td_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, d_vector_array_3d, d_real); + td_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, d_vector_array_3d, d_vector_array_3d); +} + +parameters { + real p_real; + vector[d_int] p_vector; + matrix[d_int, d_int] p_matrix; + row_vector[d_int] p_row_vector; + array[d_int] real p_real_array_1d; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int] row_vector[d_int] p_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + + +} + +transformed parameters { + real transformed_param_real; + vector[d_int] transformed_param_vector; + matrix[d_int, d_int] transformed_param_matrix; + row_vector[d_int] transformed_param_row_vector; + array[d_int] real transformed_param_real_array_1d; + array[d_int, 2] real transformed_param_real_array_2d; + array[d_int, 2, 3] real transformed_param_real_array_3d; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] row_vector[d_int] transformed_param_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_param_matrix = offset_multiplier_constrain(d_matrix, d_matrix, d_matrix); + transformed_param_matrix = offset_multiplier_constrain(d_matrix, d_matrix, d_real); + transformed_param_matrix = offset_multiplier_constrain(d_matrix, d_matrix, p_matrix); + transformed_param_matrix = offset_multiplier_constrain(d_matrix, d_matrix, p_real); + transformed_param_matrix = offset_multiplier_constrain(d_matrix, d_real, d_matrix); + transformed_param_matrix = offset_multiplier_constrain(d_matrix, d_real, p_matrix); + transformed_param_matrix = offset_multiplier_constrain(d_matrix, p_matrix, d_matrix); + transformed_param_matrix = offset_multiplier_constrain(d_matrix, p_matrix, d_real); + transformed_param_matrix = offset_multiplier_constrain(d_matrix, p_matrix, p_matrix); + transformed_param_matrix = offset_multiplier_constrain(d_matrix, p_matrix, p_real); + transformed_param_matrix = offset_multiplier_constrain(d_matrix, p_real, d_matrix); + transformed_param_matrix = offset_multiplier_constrain(d_matrix, p_real, p_matrix); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, d_matrix, d_matrix); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, d_matrix, d_real); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, d_matrix, p_matrix); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, d_matrix, p_real); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, d_real, d_matrix); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, d_real, p_matrix); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, p_matrix, d_matrix); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, p_matrix, d_real); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, p_matrix, p_matrix); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, p_matrix, p_real); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, p_real, d_matrix); + transformed_param_matrix = offset_multiplier_constrain(p_matrix, p_real, p_matrix); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(d_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_constrain(p_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(d_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_constrain(p_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(d_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_constrain(p_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_real = offset_multiplier_constrain(d_real, d_real, d_real); + transformed_param_real = offset_multiplier_constrain(d_real, d_real, p_real); + transformed_param_real = offset_multiplier_constrain(d_real, p_real, d_real); + transformed_param_real = offset_multiplier_constrain(d_real, p_real, p_real); + transformed_param_real = offset_multiplier_constrain(p_real, d_real, d_real); + transformed_param_real = offset_multiplier_constrain(p_real, d_real, p_real); + transformed_param_real = offset_multiplier_constrain(p_real, p_real, d_real); + transformed_param_real = offset_multiplier_constrain(p_real, p_real, p_real); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, d_real, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, d_real, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_1d = offset_multiplier_constrain(d_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, d_real, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, d_real, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_1d = offset_multiplier_constrain(p_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_2d = offset_multiplier_constrain(d_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_2d = offset_multiplier_constrain(p_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_3d = offset_multiplier_constrain(d_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_3d = offset_multiplier_constrain(p_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, d_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, d_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, d_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, d_row_vector, d_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, d_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, p_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, p_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, p_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, p_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_constrain(d_row_vector, p_row_vector, p_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, d_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, d_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, d_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, d_row_vector, d_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, d_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, p_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, p_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, p_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, p_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_constrain(p_row_vector, p_row_vector, p_row_vector); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(d_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_constrain(p_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(d_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_constrain(p_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(d_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = offset_multiplier_constrain(p_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_vector = offset_multiplier_constrain(d_vector, d_real, d_vector); + transformed_param_vector = offset_multiplier_constrain(d_vector, d_real, p_vector); + transformed_param_vector = offset_multiplier_constrain(d_vector, d_vector, d_real); + transformed_param_vector = offset_multiplier_constrain(d_vector, d_vector, d_vector); + transformed_param_vector = offset_multiplier_constrain(d_vector, d_vector, p_real); + transformed_param_vector = offset_multiplier_constrain(d_vector, d_vector, p_vector); + transformed_param_vector = offset_multiplier_constrain(d_vector, p_real, d_vector); + transformed_param_vector = offset_multiplier_constrain(d_vector, p_real, p_vector); + transformed_param_vector = offset_multiplier_constrain(d_vector, p_vector, d_real); + transformed_param_vector = offset_multiplier_constrain(d_vector, p_vector, d_vector); + transformed_param_vector = offset_multiplier_constrain(d_vector, p_vector, p_real); + transformed_param_vector = offset_multiplier_constrain(d_vector, p_vector, p_vector); + transformed_param_vector = offset_multiplier_constrain(p_vector, d_real, d_vector); + transformed_param_vector = offset_multiplier_constrain(p_vector, d_real, p_vector); + transformed_param_vector = offset_multiplier_constrain(p_vector, d_vector, d_real); + transformed_param_vector = offset_multiplier_constrain(p_vector, d_vector, d_vector); + transformed_param_vector = offset_multiplier_constrain(p_vector, d_vector, p_real); + transformed_param_vector = offset_multiplier_constrain(p_vector, d_vector, p_vector); + transformed_param_vector = offset_multiplier_constrain(p_vector, p_real, d_vector); + transformed_param_vector = offset_multiplier_constrain(p_vector, p_real, p_vector); + transformed_param_vector = offset_multiplier_constrain(p_vector, p_vector, d_real); + transformed_param_vector = offset_multiplier_constrain(p_vector, p_vector, d_vector); + transformed_param_vector = offset_multiplier_constrain(p_vector, p_vector, p_real); + transformed_param_vector = offset_multiplier_constrain(p_vector, p_vector, p_vector); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_vector_array_1d = offset_multiplier_constrain(d_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_vector_array_1d = offset_multiplier_constrain(p_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_vector_array_2d = offset_multiplier_constrain(d_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_vector_array_2d = offset_multiplier_constrain(p_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_vector_array_3d = offset_multiplier_constrain(d_vector_array_3d, p_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_vector_array_3d = offset_multiplier_constrain(p_vector_array_3d, p_vector_array_3d, p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/offset_multiplier_jacobian.stan b/test/integration/good/function-signatures/math/transforms/offset_multiplier_jacobian.stan new file mode 100644 index 0000000000..1ba87436bb --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/offset_multiplier_jacobian.stan @@ -0,0 +1,431 @@ +data { + int d_int; + real d_real; + vector[d_int] d_vector; + matrix[d_int, d_int] d_matrix; + row_vector[d_int] d_row_vector; + array[d_int] real d_real_array_1d; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int] row_vector[d_int] d_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; + + +} + +parameters { + real p_real; + vector[d_int] p_vector; + matrix[d_int, d_int] p_matrix; + row_vector[d_int] p_row_vector; + array[d_int] real p_real_array_1d; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int] row_vector[d_int] p_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + + +} + +transformed parameters { + real transformed_param_real; + vector[d_int] transformed_param_vector; + matrix[d_int, d_int] transformed_param_matrix; + row_vector[d_int] transformed_param_row_vector; + array[d_int] real transformed_param_real_array_1d; + array[d_int, 2] real transformed_param_real_array_2d; + array[d_int, 2, 3] real transformed_param_real_array_3d; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] row_vector[d_int] transformed_param_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_param_real = offset_multiplier_jacobian(p_real, p_real, d_real); + transformed_param_real = offset_multiplier_jacobian(p_real, d_real, d_real); + transformed_param_real = offset_multiplier_jacobian(d_real, d_real, d_real); + transformed_param_real = offset_multiplier_jacobian(p_real, p_real, p_real); + transformed_param_real = offset_multiplier_jacobian(d_real, p_real, d_real); + transformed_param_real = offset_multiplier_jacobian(d_real, p_real, p_real); + transformed_param_real = offset_multiplier_jacobian(d_real, d_real, p_real); + transformed_param_real = offset_multiplier_jacobian(p_real, d_real, p_real); + transformed_param_vector = offset_multiplier_jacobian(d_vector, d_real, p_vector); + transformed_param_vector = offset_multiplier_jacobian(p_vector, p_vector, d_real); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, d_real, d_matrix); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, d_matrix, d_real); + transformed_param_vector = offset_multiplier_jacobian(d_vector, p_vector, p_real); + transformed_param_vector = offset_multiplier_jacobian(d_vector, d_vector, p_real); + transformed_param_vector = offset_multiplier_jacobian(p_vector, d_vector, d_real); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, p_real, d_matrix); + transformed_param_vector = offset_multiplier_jacobian(d_vector, p_vector, d_real); + transformed_param_vector = offset_multiplier_jacobian(p_vector, p_vector, p_real); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, p_matrix, d_real); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, d_matrix, p_real); + transformed_param_vector = offset_multiplier_jacobian(p_vector, d_real, p_vector); + transformed_param_vector = offset_multiplier_jacobian(d_vector, d_vector, d_real); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, d_matrix, d_real); + transformed_param_vector = offset_multiplier_jacobian(d_vector, d_real, d_vector); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, p_real, p_matrix); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, p_matrix, p_real); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, p_real, d_matrix); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, d_real, d_matrix); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, p_matrix, d_real); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, d_real, p_matrix); + transformed_param_vector = offset_multiplier_jacobian(p_vector, p_real, p_vector); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, p_real, p_matrix); + transformed_param_vector = offset_multiplier_jacobian(d_vector, p_real, d_vector); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, d_matrix, p_real); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, p_matrix, p_real); + transformed_param_vector = offset_multiplier_jacobian(d_vector, p_real, p_vector); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, d_real, p_matrix); + transformed_param_vector = offset_multiplier_jacobian(p_vector, p_real, d_vector); + transformed_param_vector = offset_multiplier_jacobian(p_vector, d_real, d_vector); + transformed_param_vector = offset_multiplier_jacobian(p_vector, d_vector, p_real); + transformed_param_vector = offset_multiplier_jacobian(d_vector, p_vector, d_vector); + transformed_param_vector = offset_multiplier_jacobian(d_vector, d_vector, p_vector); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, d_matrix, p_matrix); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, p_matrix, d_matrix); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, d_matrix, d_matrix); + transformed_param_vector = offset_multiplier_jacobian(p_vector, d_vector, p_vector); + transformed_param_vector = offset_multiplier_jacobian(p_vector, p_vector, d_vector); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, p_matrix, d_matrix); + transformed_param_vector = offset_multiplier_jacobian(p_vector, d_vector, d_vector); + transformed_param_vector = offset_multiplier_jacobian(p_vector, p_vector, p_vector); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, p_matrix, p_matrix); + transformed_param_matrix = offset_multiplier_jacobian(d_matrix, p_matrix, p_matrix); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, d_matrix, d_matrix); + transformed_param_matrix = offset_multiplier_jacobian(p_matrix, d_matrix, p_matrix); + transformed_param_vector = offset_multiplier_jacobian(d_vector, d_vector, d_vector); + transformed_param_vector = offset_multiplier_jacobian(d_vector, p_vector, p_vector); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, d_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, p_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, d_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, p_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, p_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, d_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, p_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, d_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, d_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, p_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, p_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, d_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, d_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, p_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, d_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, p_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, p_row_vector, p_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, d_row_vector, d_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(p_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, p_row_vector, p_row_vector); + transformed_param_row_vector = offset_multiplier_jacobian(d_row_vector, d_row_vector, d_row_vector); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, d_real, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, d_real, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, d_real, d_real_array_1d); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, d_real, d_real_array_1d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_2d = offset_multiplier_jacobian(d_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_2d = offset_multiplier_jacobian(p_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_real_array_1d = offset_multiplier_jacobian(d_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_3d = offset_multiplier_jacobian(d_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_1d = offset_multiplier_jacobian(p_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_3d = offset_multiplier_jacobian(p_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, p_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, p_vector_array_3d, p_vector_array_3d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(d_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(d_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_vector_array_3d = offset_multiplier_jacobian(p_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(d_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(p_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(d_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_1d = offset_multiplier_jacobian(d_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_jacobian(p_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_matrix_array_3d = offset_multiplier_jacobian(p_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(p_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_jacobian(d_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_jacobian(p_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(p_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_3d = offset_multiplier_jacobian(d_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(p_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(d_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_jacobian(p_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_jacobian(d_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/offset_multiplier_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/offset_multiplier_unconstrain.stan new file mode 100644 index 0000000000..ff9ee1c756 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/offset_multiplier_unconstrain.stan @@ -0,0 +1,498 @@ +data { + int d_int; + real d_real; + vector[d_int] d_vector; + matrix[d_int, d_int] d_matrix; + row_vector[d_int] d_row_vector; + array[d_int] real d_real_array_1d; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int] row_vector[d_int] d_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; + + +} + +transformed data { + int td_int; + real td_real; + vector[d_int] td_vector; + matrix[d_int, d_int] td_matrix; + row_vector[d_int] td_row_vector; + array[d_int] real td_real_array_1d; + array[d_int, 2] real td_real_array_2d; + array[d_int, 2, 3] real td_real_array_3d; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int] row_vector[d_int] td_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2] row_vector[d_int] td_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] td_row_vector_array_3d; + + td_matrix = offset_multiplier_unconstrain(d_matrix, d_matrix, d_matrix); + td_matrix = offset_multiplier_unconstrain(d_matrix, d_matrix, d_real); + td_matrix = offset_multiplier_unconstrain(d_matrix, d_real, d_matrix); + td_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + td_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, d_matrix_array_1d, d_real); + td_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, d_real, d_matrix_array_1d); + td_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + td_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, d_matrix_array_2d, d_real); + td_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, d_real, d_matrix_array_2d); + td_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + td_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, d_matrix_array_3d, d_real); + td_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, d_real, d_matrix_array_3d); + td_real = offset_multiplier_unconstrain(d_real, d_real, d_real); + td_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, d_real, d_real_array_1d); + td_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, d_real_array_1d, d_real); + td_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, d_real_array_1d, d_real_array_1d); + td_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, d_real, d_real_array_2d); + td_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, d_real_array_2d, d_real); + td_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, d_real_array_2d, d_real_array_2d); + td_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, d_real, d_real_array_3d); + td_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, d_real_array_3d, d_real); + td_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, d_real_array_3d, d_real_array_3d); + td_row_vector = offset_multiplier_unconstrain(d_row_vector, d_real, d_row_vector); + td_row_vector = offset_multiplier_unconstrain(d_row_vector, d_row_vector, d_real); + td_row_vector = offset_multiplier_unconstrain(d_row_vector, d_row_vector, d_row_vector); + td_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, d_real, d_row_vector_array_1d); + td_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, d_real); + td_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + td_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, d_real, d_row_vector_array_2d); + td_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, d_real); + td_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + td_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, d_real, d_row_vector_array_3d); + td_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, d_real); + td_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + td_vector = offset_multiplier_unconstrain(d_vector, d_real, d_vector); + td_vector = offset_multiplier_unconstrain(d_vector, d_vector, d_real); + td_vector = offset_multiplier_unconstrain(d_vector, d_vector, d_vector); + td_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, d_real, d_vector_array_1d); + td_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, d_vector_array_1d, d_real); + td_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + td_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, d_real, d_vector_array_2d); + td_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, d_vector_array_2d, d_real); + td_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + td_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, d_real, d_vector_array_3d); + td_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, d_vector_array_3d, d_real); + td_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, d_vector_array_3d, d_vector_array_3d); +} + +parameters { + real p_real; + vector[d_int] p_vector; + matrix[d_int, d_int] p_matrix; + row_vector[d_int] p_row_vector; + array[d_int] real p_real_array_1d; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int] row_vector[d_int] p_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + + +} + +transformed parameters { + real transformed_param_real; + vector[d_int] transformed_param_vector; + matrix[d_int, d_int] transformed_param_matrix; + row_vector[d_int] transformed_param_row_vector; + array[d_int] real transformed_param_real_array_1d; + array[d_int, 2] real transformed_param_real_array_2d; + array[d_int, 2, 3] real transformed_param_real_array_3d; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] row_vector[d_int] transformed_param_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, d_matrix, d_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, d_matrix, d_real); + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, d_matrix, p_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, d_matrix, p_real); + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, d_real, d_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, d_real, p_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, p_matrix, d_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, p_matrix, d_real); + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, p_matrix, p_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, p_matrix, p_real); + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, p_real, d_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(d_matrix, p_real, p_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, d_matrix, d_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, d_matrix, d_real); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, d_matrix, p_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, d_matrix, p_real); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, d_real, d_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, d_real, p_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, p_matrix, d_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, p_matrix, d_real); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, p_matrix, p_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, p_matrix, p_real); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, p_real, d_matrix); + transformed_param_matrix = offset_multiplier_unconstrain(p_matrix, p_real, p_matrix); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(d_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, d_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, d_real, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, p_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, p_real, d_matrix_array_1d); + transformed_param_matrix_array_1d = offset_multiplier_unconstrain(p_matrix_array_1d, p_real, p_matrix_array_1d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(d_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, d_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, d_real, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, p_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, p_real, d_matrix_array_2d); + transformed_param_matrix_array_2d = offset_multiplier_unconstrain(p_matrix_array_2d, p_real, p_matrix_array_2d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(d_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, d_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, d_real, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, p_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, p_real, d_matrix_array_3d); + transformed_param_matrix_array_3d = offset_multiplier_unconstrain(p_matrix_array_3d, p_real, p_matrix_array_3d); + transformed_param_real = offset_multiplier_unconstrain(d_real, d_real, d_real); + transformed_param_real = offset_multiplier_unconstrain(d_real, d_real, p_real); + transformed_param_real = offset_multiplier_unconstrain(d_real, p_real, d_real); + transformed_param_real = offset_multiplier_unconstrain(d_real, p_real, p_real); + transformed_param_real = offset_multiplier_unconstrain(p_real, d_real, d_real); + transformed_param_real = offset_multiplier_unconstrain(p_real, d_real, p_real); + transformed_param_real = offset_multiplier_unconstrain(p_real, p_real, d_real); + transformed_param_real = offset_multiplier_unconstrain(p_real, p_real, p_real); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, d_real, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, d_real, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_1d = offset_multiplier_unconstrain(d_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, d_real, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, d_real, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, d_real_array_1d, d_real); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, d_real_array_1d, p_real); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, p_real, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, p_real, p_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, p_real_array_1d, d_real); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, p_real_array_1d, p_real); + transformed_param_real_array_1d = offset_multiplier_unconstrain(p_real_array_1d, p_real_array_1d, p_real_array_1d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_2d = offset_multiplier_unconstrain(d_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, d_real, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, d_real, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, d_real_array_2d, d_real); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, d_real_array_2d, p_real); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, p_real, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, p_real, p_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, p_real_array_2d, d_real); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, p_real_array_2d, p_real); + transformed_param_real_array_2d = offset_multiplier_unconstrain(p_real_array_2d, p_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_3d = offset_multiplier_unconstrain(d_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, d_real, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, d_real, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, d_real_array_3d, d_real); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, d_real_array_3d, p_real); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, p_real, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, p_real, p_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, p_real_array_3d, d_real); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, p_real_array_3d, p_real); + transformed_param_real_array_3d = offset_multiplier_unconstrain(p_real_array_3d, p_real_array_3d, p_real_array_3d); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, d_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, d_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, d_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, d_row_vector, d_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, d_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, p_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, p_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, p_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, p_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_unconstrain(d_row_vector, p_row_vector, p_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, d_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, d_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, d_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, d_row_vector, d_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, d_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, d_row_vector, p_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, p_real, d_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, p_real, p_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, p_row_vector, d_real); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, p_row_vector, d_row_vector); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, p_row_vector, p_real); + transformed_param_row_vector = offset_multiplier_unconstrain(p_row_vector, p_row_vector, p_row_vector); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(d_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, d_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, d_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, p_real, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, p_real, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = offset_multiplier_unconstrain(p_row_vector_array_1d, p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(d_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, d_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, d_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, p_real, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, p_real, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = offset_multiplier_unconstrain(p_row_vector_array_2d, p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(d_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, d_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, d_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, p_real, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, p_real, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = offset_multiplier_unconstrain(p_row_vector_array_3d, p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, d_real, d_vector); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, d_real, p_vector); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, d_vector, d_real); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, d_vector, d_vector); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, d_vector, p_real); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, d_vector, p_vector); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, p_real, d_vector); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, p_real, p_vector); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, p_vector, d_real); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, p_vector, d_vector); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, p_vector, p_real); + transformed_param_vector = offset_multiplier_unconstrain(d_vector, p_vector, p_vector); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, d_real, d_vector); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, d_real, p_vector); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, d_vector, d_real); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, d_vector, d_vector); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, d_vector, p_real); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, d_vector, p_vector); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, p_real, d_vector); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, p_real, p_vector); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, p_vector, d_real); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, p_vector, d_vector); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, p_vector, p_real); + transformed_param_vector = offset_multiplier_unconstrain(p_vector, p_vector, p_vector); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(d_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, d_real, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, d_real, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, d_vector_array_1d, d_real); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, d_vector_array_1d, p_real); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, p_real, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, p_real, p_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, p_vector_array_1d, d_real); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, p_vector_array_1d, p_real); + transformed_param_vector_array_1d = offset_multiplier_unconstrain(p_vector_array_1d, p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(d_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, d_real, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, d_real, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, d_vector_array_2d, d_real); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, d_vector_array_2d, p_real); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, p_real, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, p_real, p_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, p_vector_array_2d, d_real); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, p_vector_array_2d, p_real); + transformed_param_vector_array_2d = offset_multiplier_unconstrain(p_vector_array_2d, p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(d_vector_array_3d, p_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, d_real, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, d_real, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, d_vector_array_3d, d_real); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, d_vector_array_3d, p_real); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, p_real, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, p_real, p_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, p_vector_array_3d, d_real); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, p_vector_array_3d, p_real); + transformed_param_vector_array_3d = offset_multiplier_unconstrain(p_vector_array_3d, p_vector_array_3d, p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/ordered_constrain.stan b/test/integration/good/function-signatures/math/transforms/ordered_constrain.stan new file mode 100644 index 0000000000..15b6b4c4e6 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/ordered_constrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + + +} + +transformed data { + int td_int; + vector[d_int] td_vector; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + + td_vector = ordered_constrain(d_vector); + td_vector_array_1d = ordered_constrain(d_vector_array_1d); + td_vector_array_2d = ordered_constrain(d_vector_array_2d); + td_vector_array_3d = ordered_constrain(d_vector_array_3d); +} + +parameters { + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + + +} + +transformed parameters { + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + + transformed_param_vector = ordered_constrain(d_vector); + transformed_param_vector = ordered_constrain(p_vector); + transformed_param_vector_array_1d = ordered_constrain(d_vector_array_1d); + transformed_param_vector_array_1d = ordered_constrain(p_vector_array_1d); + transformed_param_vector_array_2d = ordered_constrain(d_vector_array_2d); + transformed_param_vector_array_2d = ordered_constrain(p_vector_array_2d); + transformed_param_vector_array_3d = ordered_constrain(d_vector_array_3d); + transformed_param_vector_array_3d = ordered_constrain(p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/ordered_jacobian.stan b/test/integration/good/function-signatures/math/transforms/ordered_jacobian.stan new file mode 100644 index 0000000000..d9b5ef94cb --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/ordered_jacobian.stan @@ -0,0 +1,39 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + +} + +parameters { + real p_real; + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + real y_p; +} +transformed parameters { + real transformed_real; + + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + + transformed_param_vector = ordered_jacobian(d_vector); + transformed_param_vector_array = ordered_jacobian(d_vector_array); + transformed_param_vector_array_2d = ordered_jacobian(d_vector_array_2d); + transformed_param_vector_array_3d = ordered_jacobian(d_vector_array_3d); + + transformed_param_vector = ordered_jacobian(p_vector); + transformed_param_vector_array = ordered_jacobian(p_vector_array); + transformed_param_vector_array_2d = ordered_jacobian(p_vector_array_2d); + transformed_param_vector_array_3d = ordered_jacobian(p_vector_array_3d); +} +model { + y_p ~ normal(0, 1); +} + diff --git a/test/integration/good/function-signatures/math/transforms/ordered_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/ordered_unconstrain.stan new file mode 100644 index 0000000000..9b4768239e --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/ordered_unconstrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + + +} + +transformed data { + int td_int; + vector[d_int] td_vector; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + + td_vector = ordered_unconstrain(d_vector); + td_vector_array_1d = ordered_unconstrain(d_vector_array_1d); + td_vector_array_2d = ordered_unconstrain(d_vector_array_2d); + td_vector_array_3d = ordered_unconstrain(d_vector_array_3d); +} + +parameters { + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + + +} + +transformed parameters { + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + + transformed_param_vector = ordered_unconstrain(d_vector); + transformed_param_vector = ordered_unconstrain(p_vector); + transformed_param_vector_array_1d = ordered_unconstrain(d_vector_array_1d); + transformed_param_vector_array_1d = ordered_unconstrain(p_vector_array_1d); + transformed_param_vector_array_2d = ordered_unconstrain(d_vector_array_2d); + transformed_param_vector_array_2d = ordered_unconstrain(p_vector_array_2d); + transformed_param_vector_array_3d = ordered_unconstrain(d_vector_array_3d); + transformed_param_vector_array_3d = ordered_unconstrain(p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/positive_ordered_constrain.stan b/test/integration/good/function-signatures/math/transforms/positive_ordered_constrain.stan new file mode 100644 index 0000000000..c3d0a5a8d4 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/positive_ordered_constrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + + +} + +transformed data { + int td_int; + vector[d_int] td_vector; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + + td_vector = positive_ordered_constrain(d_vector); + td_vector_array_1d = positive_ordered_constrain(d_vector_array_1d); + td_vector_array_2d = positive_ordered_constrain(d_vector_array_2d); + td_vector_array_3d = positive_ordered_constrain(d_vector_array_3d); +} + +parameters { + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + + +} + +transformed parameters { + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + + transformed_param_vector = positive_ordered_constrain(d_vector); + transformed_param_vector = positive_ordered_constrain(p_vector); + transformed_param_vector_array_1d = positive_ordered_constrain(d_vector_array_1d); + transformed_param_vector_array_1d = positive_ordered_constrain(p_vector_array_1d); + transformed_param_vector_array_2d = positive_ordered_constrain(d_vector_array_2d); + transformed_param_vector_array_2d = positive_ordered_constrain(p_vector_array_2d); + transformed_param_vector_array_3d = positive_ordered_constrain(d_vector_array_3d); + transformed_param_vector_array_3d = positive_ordered_constrain(p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/positive_ordered_jacobian.stan b/test/integration/good/function-signatures/math/transforms/positive_ordered_jacobian.stan new file mode 100644 index 0000000000..d061d2c39c --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/positive_ordered_jacobian.stan @@ -0,0 +1,39 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + +} + +parameters { + real p_real; + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + real y_p; +} +transformed parameters { + real transformed_real; + + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + + transformed_param_vector = positive_ordered_jacobian(d_vector); + transformed_param_vector_array = positive_ordered_jacobian(d_vector_array); + transformed_param_vector_array_2d = positive_ordered_jacobian(d_vector_array_2d); + transformed_param_vector_array_3d = positive_ordered_jacobian(d_vector_array_3d); + + transformed_param_vector = positive_ordered_jacobian(p_vector); + transformed_param_vector_array = positive_ordered_jacobian(p_vector_array); + transformed_param_vector_array_2d = positive_ordered_jacobian(p_vector_array_2d); + transformed_param_vector_array_3d = positive_ordered_jacobian(p_vector_array_3d); +} +model { + y_p ~ normal(0, 1); +} + diff --git a/test/integration/good/function-signatures/math/transforms/positive_ordered_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/positive_ordered_unconstrain.stan new file mode 100644 index 0000000000..ec5f88e140 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/positive_ordered_unconstrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + + +} + +transformed data { + int td_int; + vector[d_int] td_vector; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + + td_vector = positive_ordered_unconstrain(d_vector); + td_vector_array_1d = positive_ordered_unconstrain(d_vector_array_1d); + td_vector_array_2d = positive_ordered_unconstrain(d_vector_array_2d); + td_vector_array_3d = positive_ordered_unconstrain(d_vector_array_3d); +} + +parameters { + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + + +} + +transformed parameters { + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + + transformed_param_vector = positive_ordered_unconstrain(d_vector); + transformed_param_vector = positive_ordered_unconstrain(p_vector); + transformed_param_vector_array_1d = positive_ordered_unconstrain(d_vector_array_1d); + transformed_param_vector_array_1d = positive_ordered_unconstrain(p_vector_array_1d); + transformed_param_vector_array_2d = positive_ordered_unconstrain(d_vector_array_2d); + transformed_param_vector_array_2d = positive_ordered_unconstrain(p_vector_array_2d); + transformed_param_vector_array_3d = positive_ordered_unconstrain(d_vector_array_3d); + transformed_param_vector_array_3d = positive_ordered_unconstrain(p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/simplex_constrain.stan b/test/integration/good/function-signatures/math/transforms/simplex_constrain.stan new file mode 100644 index 0000000000..0a331f64be --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/simplex_constrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + + +} + +transformed data { + int td_int; + vector[d_int+1] td_vector; + array[d_int] vector[d_int+1] td_vector_array_1d; + array[d_int, 2] vector[d_int+1] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int+1] td_vector_array_3d; + + td_vector = simplex_constrain(d_vector); + td_vector_array_1d = simplex_constrain(d_vector_array_1d); + td_vector_array_2d = simplex_constrain(d_vector_array_2d); + td_vector_array_3d = simplex_constrain(d_vector_array_3d); +} + +parameters { + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + + +} + +transformed parameters { + vector[d_int+1] transformed_param_vector; + array[d_int] vector[d_int+1] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int+1] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int+1] transformed_param_vector_array_3d; + + transformed_param_vector = simplex_constrain(d_vector); + transformed_param_vector = simplex_constrain(p_vector); + transformed_param_vector_array_1d = simplex_constrain(d_vector_array_1d); + transformed_param_vector_array_1d = simplex_constrain(p_vector_array_1d); + transformed_param_vector_array_2d = simplex_constrain(d_vector_array_2d); + transformed_param_vector_array_2d = simplex_constrain(p_vector_array_2d); + transformed_param_vector_array_3d = simplex_constrain(d_vector_array_3d); + transformed_param_vector_array_3d = simplex_constrain(p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/simplex_jacobian.stan b/test/integration/good/function-signatures/math/transforms/simplex_jacobian.stan new file mode 100644 index 0000000000..3436377dd8 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/simplex_jacobian.stan @@ -0,0 +1,39 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + +} + +parameters { + real p_real; + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + real y_p; +} +transformed parameters { + real transformed_real; + + vector[d_int+1] transformed_param_vector; + array[d_int] vector[d_int+1] transformed_param_vector_array; + array[d_int, 2] vector[d_int+1] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int+1] transformed_param_vector_array_3d; + + transformed_param_vector = simplex_jacobian(d_vector); + transformed_param_vector_array = simplex_jacobian(d_vector_array); + transformed_param_vector_array_2d = simplex_jacobian(d_vector_array_2d); + transformed_param_vector_array_3d = simplex_jacobian(d_vector_array_3d); + + transformed_param_vector = simplex_jacobian(p_vector); + transformed_param_vector_array = simplex_jacobian(p_vector_array); + transformed_param_vector_array_2d = simplex_jacobian(p_vector_array_2d); + transformed_param_vector_array_3d = simplex_jacobian(p_vector_array_3d); +} +model { + y_p ~ normal(0, 1); +} + diff --git a/test/integration/good/function-signatures/math/transforms/simplex_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/simplex_unconstrain.stan new file mode 100644 index 0000000000..76a814492d --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/simplex_unconstrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + vector[d_int+1] d_vector; + array[d_int] vector[d_int+1] d_vector_array_1d; + array[d_int, 2] vector[d_int+1] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int+1] d_vector_array_3d; + + +} + +transformed data { + int td_int; + vector[d_int] td_vector; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + + td_vector = simplex_unconstrain(d_vector); + td_vector_array_1d = simplex_unconstrain(d_vector_array_1d); + td_vector_array_2d = simplex_unconstrain(d_vector_array_2d); + td_vector_array_3d = simplex_unconstrain(d_vector_array_3d); +} + +parameters { + vector[d_int+1] p_vector; + array[d_int] vector[d_int+1] p_vector_array_1d; + array[d_int, 2] vector[d_int+1] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int+1] p_vector_array_3d; + + +} + +transformed parameters { + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + + transformed_param_vector = simplex_unconstrain(d_vector); + transformed_param_vector = simplex_unconstrain(p_vector); + transformed_param_vector_array_1d = simplex_unconstrain(d_vector_array_1d); + transformed_param_vector_array_1d = simplex_unconstrain(p_vector_array_1d); + transformed_param_vector_array_2d = simplex_unconstrain(d_vector_array_2d); + transformed_param_vector_array_2d = simplex_unconstrain(p_vector_array_2d); + transformed_param_vector_array_3d = simplex_unconstrain(d_vector_array_3d); + transformed_param_vector_array_3d = simplex_unconstrain(p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/stochastic_column_constrain.stan b/test/integration/good/function-signatures/math/transforms/stochastic_column_constrain.stan new file mode 100644 index 0000000000..249d1c85c7 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/stochastic_column_constrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + matrix[d_int, d_int] d_matrix; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int+1, d_int] td_matrix; + array[d_int] matrix[d_int+1, d_int] td_matrix_array_1d; + array[d_int, 2] matrix[d_int+1, d_int] td_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int+1, d_int] td_matrix_array_3d; + + td_matrix = stochastic_column_constrain(d_matrix); + td_matrix_array_1d = stochastic_column_constrain(d_matrix_array_1d); + td_matrix_array_2d = stochastic_column_constrain(d_matrix_array_2d); + td_matrix_array_3d = stochastic_column_constrain(d_matrix_array_3d); +} + +parameters { + matrix[d_int, d_int] p_matrix; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + array[d_int] matrix[d_int+1, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int+1, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int+1, d_int] transformed_param_matrix_array_3d; + + transformed_param_matrix = stochastic_column_constrain(d_matrix); + transformed_param_matrix = stochastic_column_constrain(p_matrix); + transformed_param_matrix_array_1d = stochastic_column_constrain(d_matrix_array_1d); + transformed_param_matrix_array_1d = stochastic_column_constrain(p_matrix_array_1d); + transformed_param_matrix_array_2d = stochastic_column_constrain(d_matrix_array_2d); + transformed_param_matrix_array_2d = stochastic_column_constrain(p_matrix_array_2d); + transformed_param_matrix_array_3d = stochastic_column_constrain(d_matrix_array_3d); + transformed_param_matrix_array_3d = stochastic_column_constrain(p_matrix_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/stochastic_column_jacobian.stan b/test/integration/good/function-signatures/math/transforms/stochastic_column_jacobian.stan new file mode 100644 index 0000000000..0eb3a97b0a --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/stochastic_column_jacobian.stan @@ -0,0 +1,35 @@ +data { + int d_int; + matrix[d_int, d_int] d_matrix; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + + +} + +parameters { + matrix[d_int, d_int] p_matrix; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + + +} + +transformed parameters { + matrix[d_int+1, d_int] transformed_param_matrix; + array[d_int] matrix[d_int+1, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int+1, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int+1, d_int] transformed_param_matrix_array_3d; + + transformed_param_matrix = stochastic_column_jacobian(d_matrix); + transformed_param_matrix = stochastic_column_jacobian(p_matrix); + transformed_param_matrix_array_1d = stochastic_column_jacobian(d_matrix_array_1d); + transformed_param_matrix_array_1d = stochastic_column_jacobian(p_matrix_array_1d); + transformed_param_matrix_array_2d = stochastic_column_jacobian(d_matrix_array_2d); + transformed_param_matrix_array_2d = stochastic_column_jacobian(p_matrix_array_2d); + transformed_param_matrix_array_3d = stochastic_column_jacobian(d_matrix_array_3d); + transformed_param_matrix_array_3d = stochastic_column_jacobian(p_matrix_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/stochastic_column_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/stochastic_column_unconstrain.stan new file mode 100644 index 0000000000..cd494b60ff --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/stochastic_column_unconstrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + matrix[d_int+1, d_int] d_matrix; + array[d_int] matrix[d_int+1, d_int] d_matrix_array_1d; + array[d_int, 2] matrix[d_int+1, d_int] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int+1, d_int] d_matrix_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int, d_int] td_matrix; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + + td_matrix = stochastic_column_unconstrain(d_matrix); + td_matrix_array_1d = stochastic_column_unconstrain(d_matrix_array_1d); + td_matrix_array_2d = stochastic_column_unconstrain(d_matrix_array_2d); + td_matrix_array_3d = stochastic_column_unconstrain(d_matrix_array_3d); +} + +parameters { + matrix[d_int+1, d_int] p_matrix; + array[d_int] matrix[d_int+1, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int+1, d_int] p_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int+1, d_int] p_matrix_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + + transformed_param_matrix = stochastic_column_unconstrain(d_matrix); + transformed_param_matrix = stochastic_column_unconstrain(p_matrix); + transformed_param_matrix_array_1d = stochastic_column_unconstrain(d_matrix_array_1d); + transformed_param_matrix_array_1d = stochastic_column_unconstrain(p_matrix_array_1d); + transformed_param_matrix_array_2d = stochastic_column_unconstrain(d_matrix_array_2d); + transformed_param_matrix_array_2d = stochastic_column_unconstrain(p_matrix_array_2d); + transformed_param_matrix_array_3d = stochastic_column_unconstrain(d_matrix_array_3d); + transformed_param_matrix_array_3d = stochastic_column_unconstrain(p_matrix_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/stochastic_row_constrain.stan b/test/integration/good/function-signatures/math/transforms/stochastic_row_constrain.stan new file mode 100644 index 0000000000..90d5878901 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/stochastic_row_constrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + matrix[d_int, d_int] d_matrix; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int, d_int+1] td_matrix; + array[d_int] matrix[d_int, d_int+1] td_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int+1] td_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int+1] td_matrix_array_3d; + + td_matrix = stochastic_row_constrain(d_matrix); + td_matrix_array_1d = stochastic_row_constrain(d_matrix_array_1d); + td_matrix_array_2d = stochastic_row_constrain(d_matrix_array_2d); + td_matrix_array_3d = stochastic_row_constrain(d_matrix_array_3d); +} + +parameters { + matrix[d_int, d_int] p_matrix; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int+1] transformed_param_matrix; + array[d_int] matrix[d_int, d_int+1] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int+1] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int+1] transformed_param_matrix_array_3d; + + transformed_param_matrix = stochastic_row_constrain(d_matrix); + transformed_param_matrix = stochastic_row_constrain(p_matrix); + transformed_param_matrix_array_1d = stochastic_row_constrain(d_matrix_array_1d); + transformed_param_matrix_array_1d = stochastic_row_constrain(p_matrix_array_1d); + transformed_param_matrix_array_2d = stochastic_row_constrain(d_matrix_array_2d); + transformed_param_matrix_array_2d = stochastic_row_constrain(p_matrix_array_2d); + transformed_param_matrix_array_3d = stochastic_row_constrain(d_matrix_array_3d); + transformed_param_matrix_array_3d = stochastic_row_constrain(p_matrix_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/stochastic_row_jacobian.stan b/test/integration/good/function-signatures/math/transforms/stochastic_row_jacobian.stan new file mode 100644 index 0000000000..cfc52963a8 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/stochastic_row_jacobian.stan @@ -0,0 +1,35 @@ +data { + int d_int; + matrix[d_int, d_int] d_matrix; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + + +} + +parameters { + matrix[d_int, d_int] p_matrix; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + + transformed_param_matrix = stochastic_row_jacobian(d_matrix); + transformed_param_matrix = stochastic_row_jacobian(p_matrix); + transformed_param_matrix_array_1d = stochastic_row_jacobian(d_matrix_array_1d); + transformed_param_matrix_array_1d = stochastic_row_jacobian(p_matrix_array_1d); + transformed_param_matrix_array_2d = stochastic_row_jacobian(d_matrix_array_2d); + transformed_param_matrix_array_2d = stochastic_row_jacobian(p_matrix_array_2d); + transformed_param_matrix_array_3d = stochastic_row_jacobian(d_matrix_array_3d); + transformed_param_matrix_array_3d = stochastic_row_jacobian(p_matrix_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/stochastic_row_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/stochastic_row_unconstrain.stan new file mode 100644 index 0000000000..e1d707ffa8 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/stochastic_row_unconstrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + matrix[d_int, d_int+1] d_matrix; + array[d_int] matrix[d_int, d_int+1] d_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int+1] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int+1] d_matrix_array_3d; + + +} + +transformed data { + int td_int; + matrix[d_int, d_int] td_matrix; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + + td_matrix = stochastic_row_unconstrain(d_matrix); + td_matrix_array_1d = stochastic_row_unconstrain(d_matrix_array_1d); + td_matrix_array_2d = stochastic_row_unconstrain(d_matrix_array_2d); + td_matrix_array_3d = stochastic_row_unconstrain(d_matrix_array_3d); +} + +parameters { + matrix[d_int, d_int+1] p_matrix; + array[d_int] matrix[d_int, d_int+1] p_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int+1] p_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int+1] p_matrix_array_3d; + + +} + +transformed parameters { + matrix[d_int, d_int] transformed_param_matrix; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + + transformed_param_matrix = stochastic_row_unconstrain(d_matrix); + transformed_param_matrix = stochastic_row_unconstrain(p_matrix); + transformed_param_matrix_array_1d = stochastic_row_unconstrain(d_matrix_array_1d); + transformed_param_matrix_array_1d = stochastic_row_unconstrain(p_matrix_array_1d); + transformed_param_matrix_array_2d = stochastic_row_unconstrain(d_matrix_array_2d); + transformed_param_matrix_array_2d = stochastic_row_unconstrain(p_matrix_array_2d); + transformed_param_matrix_array_3d = stochastic_row_unconstrain(d_matrix_array_3d); + transformed_param_matrix_array_3d = stochastic_row_unconstrain(p_matrix_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/sum_to_zero_constrain.stan b/test/integration/good/function-signatures/math/transforms/sum_to_zero_constrain.stan new file mode 100644 index 0000000000..15dacdb922 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/sum_to_zero_constrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + + +} + +transformed data { + int td_int; + vector[d_int+1] td_vector; + array[d_int] vector[d_int+1] td_vector_array_1d; + array[d_int, 2] vector[d_int+1] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int+1] td_vector_array_3d; + + td_vector = sum_to_zero_constrain(d_vector); + td_vector_array_1d = sum_to_zero_constrain(d_vector_array_1d); + td_vector_array_2d = sum_to_zero_constrain(d_vector_array_2d); + td_vector_array_3d = sum_to_zero_constrain(d_vector_array_3d); +} + +parameters { + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + + +} + +transformed parameters { + vector[d_int+1] transformed_param_vector; + array[d_int] vector[d_int+1] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int+1] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int+1] transformed_param_vector_array_3d; + + transformed_param_vector = sum_to_zero_constrain(d_vector); + transformed_param_vector = sum_to_zero_constrain(p_vector); + transformed_param_vector_array_1d = sum_to_zero_constrain(d_vector_array_1d); + transformed_param_vector_array_1d = sum_to_zero_constrain(p_vector_array_1d); + transformed_param_vector_array_2d = sum_to_zero_constrain(d_vector_array_2d); + transformed_param_vector_array_2d = sum_to_zero_constrain(p_vector_array_2d); + transformed_param_vector_array_3d = sum_to_zero_constrain(d_vector_array_3d); + transformed_param_vector_array_3d = sum_to_zero_constrain(p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/sum_to_zero_jacobian.stan b/test/integration/good/function-signatures/math/transforms/sum_to_zero_jacobian.stan new file mode 100644 index 0000000000..f0c233bbf0 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/sum_to_zero_jacobian.stan @@ -0,0 +1,35 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + + +} + +parameters { + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + + +} + +transformed parameters { + vector[d_int+1] transformed_param_vector; + array[d_int] vector[d_int+1] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int+1] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int+1] transformed_param_vector_array_3d; + + transformed_param_vector = sum_to_zero_jacobian(d_vector); + transformed_param_vector = sum_to_zero_jacobian(p_vector); + transformed_param_vector_array_1d = sum_to_zero_jacobian(d_vector_array_1d); + transformed_param_vector_array_1d = sum_to_zero_jacobian(p_vector_array_1d); + transformed_param_vector_array_2d = sum_to_zero_jacobian(d_vector_array_2d); + transformed_param_vector_array_2d = sum_to_zero_jacobian(p_vector_array_2d); + transformed_param_vector_array_3d = sum_to_zero_jacobian(d_vector_array_3d); + transformed_param_vector_array_3d = sum_to_zero_jacobian(p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/sum_to_zero_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/sum_to_zero_unconstrain.stan new file mode 100644 index 0000000000..71dc65dd77 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/sum_to_zero_unconstrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + vector[d_int+1] d_vector; + array[d_int] vector[d_int+1] d_vector_array_1d; + array[d_int, 2] vector[d_int+1] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int+1] d_vector_array_3d; + + +} + +transformed data { + int td_int; + vector[d_int] td_vector; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + + td_vector = sum_to_zero_unconstrain(d_vector); + td_vector_array_1d = sum_to_zero_unconstrain(d_vector_array_1d); + td_vector_array_2d = sum_to_zero_unconstrain(d_vector_array_2d); + td_vector_array_3d = sum_to_zero_unconstrain(d_vector_array_3d); +} + +parameters { + vector[d_int+1] p_vector; + array[d_int] vector[d_int+1] p_vector_array_1d; + array[d_int, 2] vector[d_int+1] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int+1] p_vector_array_3d; + + +} + +transformed parameters { + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + + transformed_param_vector = sum_to_zero_unconstrain(d_vector); + transformed_param_vector = sum_to_zero_unconstrain(p_vector); + transformed_param_vector_array_1d = sum_to_zero_unconstrain(d_vector_array_1d); + transformed_param_vector_array_1d = sum_to_zero_unconstrain(p_vector_array_1d); + transformed_param_vector_array_2d = sum_to_zero_unconstrain(d_vector_array_2d); + transformed_param_vector_array_2d = sum_to_zero_unconstrain(p_vector_array_2d); + transformed_param_vector_array_3d = sum_to_zero_unconstrain(d_vector_array_3d); + transformed_param_vector_array_3d = sum_to_zero_unconstrain(p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/unit_vector_constrain.stan b/test/integration/good/function-signatures/math/transforms/unit_vector_constrain.stan new file mode 100644 index 0000000000..1f62540865 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/unit_vector_constrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + + +} + +transformed data { + int td_int; + vector[d_int] td_vector; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + + td_vector = unit_vector_constrain(d_vector); + td_vector_array_1d = unit_vector_constrain(d_vector_array_1d); + td_vector_array_2d = unit_vector_constrain(d_vector_array_2d); + td_vector_array_3d = unit_vector_constrain(d_vector_array_3d); +} + +parameters { + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + + +} + +transformed parameters { + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + + transformed_param_vector = unit_vector_constrain(d_vector); + transformed_param_vector = unit_vector_constrain(p_vector); + transformed_param_vector_array_1d = unit_vector_constrain(d_vector_array_1d); + transformed_param_vector_array_1d = unit_vector_constrain(p_vector_array_1d); + transformed_param_vector_array_2d = unit_vector_constrain(d_vector_array_2d); + transformed_param_vector_array_2d = unit_vector_constrain(p_vector_array_2d); + transformed_param_vector_array_3d = unit_vector_constrain(d_vector_array_3d); + transformed_param_vector_array_3d = unit_vector_constrain(p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/unit_vector_jacobian.stan b/test/integration/good/function-signatures/math/transforms/unit_vector_jacobian.stan new file mode 100644 index 0000000000..d061d2c39c --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/unit_vector_jacobian.stan @@ -0,0 +1,39 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + +} + +parameters { + real p_real; + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + real y_p; +} +transformed parameters { + real transformed_real; + + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + + transformed_param_vector = positive_ordered_jacobian(d_vector); + transformed_param_vector_array = positive_ordered_jacobian(d_vector_array); + transformed_param_vector_array_2d = positive_ordered_jacobian(d_vector_array_2d); + transformed_param_vector_array_3d = positive_ordered_jacobian(d_vector_array_3d); + + transformed_param_vector = positive_ordered_jacobian(p_vector); + transformed_param_vector_array = positive_ordered_jacobian(p_vector_array); + transformed_param_vector_array_2d = positive_ordered_jacobian(p_vector_array_2d); + transformed_param_vector_array_3d = positive_ordered_jacobian(p_vector_array_3d); +} +model { + y_p ~ normal(0, 1); +} + diff --git a/test/integration/good/function-signatures/math/transforms/unit_vector_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/unit_vector_unconstrain.stan new file mode 100644 index 0000000000..9b158fd074 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/unit_vector_unconstrain.stan @@ -0,0 +1,48 @@ +data { + int d_int; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + + +} + +transformed data { + int td_int; + vector[d_int] td_vector; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + + td_vector = unit_vector_unconstrain(d_vector); + td_vector_array_1d = unit_vector_unconstrain(d_vector_array_1d); + td_vector_array_2d = unit_vector_unconstrain(d_vector_array_2d); + td_vector_array_3d = unit_vector_unconstrain(d_vector_array_3d); +} + +parameters { + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + + +} + +transformed parameters { + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + + transformed_param_vector = unit_vector_unconstrain(d_vector); + transformed_param_vector = unit_vector_unconstrain(p_vector); + transformed_param_vector_array_1d = unit_vector_unconstrain(d_vector_array_1d); + transformed_param_vector_array_1d = unit_vector_unconstrain(p_vector_array_1d); + transformed_param_vector_array_2d = unit_vector_unconstrain(d_vector_array_2d); + transformed_param_vector_array_2d = unit_vector_unconstrain(p_vector_array_2d); + transformed_param_vector_array_3d = unit_vector_unconstrain(d_vector_array_3d); + transformed_param_vector_array_3d = unit_vector_unconstrain(p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/upper_bound_constrain.stan b/test/integration/good/function-signatures/math/transforms/upper_bound_constrain.stan new file mode 100644 index 0000000000..f3316340df --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/upper_bound_constrain.stan @@ -0,0 +1,239 @@ +data { + int d_int; + real d_real; + vector[d_int] d_vector; + matrix[d_int, d_int] d_matrix; + row_vector[d_int] d_row_vector; + array[d_int] real d_real_array_1d; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int] row_vector[d_int] d_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; + + +} + +transformed data { + int td_int; + real td_real; + vector[d_int] td_vector; + matrix[d_int, d_int] td_matrix; + row_vector[d_int] td_row_vector; + array[d_int] real td_real_array_1d; + array[d_int, 2] real td_real_array_2d; + array[d_int, 2, 3] real td_real_array_3d; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int] row_vector[d_int] td_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2] row_vector[d_int] td_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] td_row_vector_array_3d; + + td_matrix = upper_bound_constrain(d_matrix, d_matrix); + td_matrix = upper_bound_constrain(d_matrix, d_real); + td_matrix_array_1d = upper_bound_constrain(d_matrix_array_1d, d_matrix_array_1d); + td_matrix_array_1d = upper_bound_constrain(d_matrix_array_1d, d_real); + td_matrix_array_2d = upper_bound_constrain(d_matrix_array_2d, d_matrix_array_2d); + td_matrix_array_2d = upper_bound_constrain(d_matrix_array_2d, d_real); + td_matrix_array_3d = upper_bound_constrain(d_matrix_array_3d, d_matrix_array_3d); + td_matrix_array_3d = upper_bound_constrain(d_matrix_array_3d, d_real); + td_real = upper_bound_constrain(d_real, d_real); + td_real_array_1d = upper_bound_constrain(d_real_array_1d, d_real); + td_real_array_1d = upper_bound_constrain(d_real_array_1d, d_real_array_1d); + td_real_array_2d = upper_bound_constrain(d_real_array_2d, d_real); + td_real_array_2d = upper_bound_constrain(d_real_array_2d, d_real_array_2d); + td_real_array_3d = upper_bound_constrain(d_real_array_3d, d_real); + td_real_array_3d = upper_bound_constrain(d_real_array_3d, d_real_array_3d); + td_row_vector = upper_bound_constrain(d_row_vector, d_real); + td_row_vector = upper_bound_constrain(d_row_vector, d_row_vector); + td_row_vector_array_1d = upper_bound_constrain(d_row_vector_array_1d, d_real); + td_row_vector_array_1d = upper_bound_constrain(d_row_vector_array_1d, d_row_vector_array_1d); + td_row_vector_array_2d = upper_bound_constrain(d_row_vector_array_2d, d_real); + td_row_vector_array_2d = upper_bound_constrain(d_row_vector_array_2d, d_row_vector_array_2d); + td_row_vector_array_3d = upper_bound_constrain(d_row_vector_array_3d, d_real); + td_row_vector_array_3d = upper_bound_constrain(d_row_vector_array_3d, d_row_vector_array_3d); + td_vector = upper_bound_constrain(d_vector, d_real); + td_vector = upper_bound_constrain(d_vector, d_vector); + td_vector_array_1d = upper_bound_constrain(d_vector_array_1d, d_real); + td_vector_array_1d = upper_bound_constrain(d_vector_array_1d, d_vector_array_1d); + td_vector_array_2d = upper_bound_constrain(d_vector_array_2d, d_real); + td_vector_array_2d = upper_bound_constrain(d_vector_array_2d, d_vector_array_2d); + td_vector_array_3d = upper_bound_constrain(d_vector_array_3d, d_real); + td_vector_array_3d = upper_bound_constrain(d_vector_array_3d, d_vector_array_3d); +} + +parameters { + real p_real; + vector[d_int] p_vector; + matrix[d_int, d_int] p_matrix; + row_vector[d_int] p_row_vector; + array[d_int] real p_real_array_1d; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int] row_vector[d_int] p_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + + +} + +transformed parameters { + real transformed_param_real; + vector[d_int] transformed_param_vector; + matrix[d_int, d_int] transformed_param_matrix; + row_vector[d_int] transformed_param_row_vector; + array[d_int] real transformed_param_real_array_1d; + array[d_int, 2] real transformed_param_real_array_2d; + array[d_int, 2, 3] real transformed_param_real_array_3d; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] row_vector[d_int] transformed_param_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_param_matrix = upper_bound_constrain(d_matrix, d_matrix); + transformed_param_matrix = upper_bound_constrain(d_matrix, d_real); + transformed_param_matrix = upper_bound_constrain(d_matrix, p_matrix); + transformed_param_matrix = upper_bound_constrain(d_matrix, p_real); + transformed_param_matrix = upper_bound_constrain(p_matrix, d_matrix); + transformed_param_matrix = upper_bound_constrain(p_matrix, d_real); + transformed_param_matrix = upper_bound_constrain(p_matrix, p_matrix); + transformed_param_matrix = upper_bound_constrain(p_matrix, p_real); + transformed_param_matrix_array_1d = upper_bound_constrain(d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = upper_bound_constrain(d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = upper_bound_constrain(d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = upper_bound_constrain(d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = upper_bound_constrain(p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = upper_bound_constrain(p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = upper_bound_constrain(p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = upper_bound_constrain(p_matrix_array_1d, p_real); + transformed_param_matrix_array_2d = upper_bound_constrain(d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = upper_bound_constrain(d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = upper_bound_constrain(d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = upper_bound_constrain(d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = upper_bound_constrain(p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = upper_bound_constrain(p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = upper_bound_constrain(p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = upper_bound_constrain(p_matrix_array_2d, p_real); + transformed_param_matrix_array_3d = upper_bound_constrain(d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = upper_bound_constrain(d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = upper_bound_constrain(d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = upper_bound_constrain(d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = upper_bound_constrain(p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = upper_bound_constrain(p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = upper_bound_constrain(p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = upper_bound_constrain(p_matrix_array_3d, p_real); + transformed_param_real = upper_bound_constrain(d_real, d_real); + transformed_param_real = upper_bound_constrain(d_real, p_real); + transformed_param_real = upper_bound_constrain(p_real, d_real); + transformed_param_real = upper_bound_constrain(p_real, p_real); + transformed_param_real_array_1d = upper_bound_constrain(d_real_array_1d, d_real); + transformed_param_real_array_1d = upper_bound_constrain(d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = upper_bound_constrain(d_real_array_1d, p_real); + transformed_param_real_array_1d = upper_bound_constrain(d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = upper_bound_constrain(p_real_array_1d, d_real); + transformed_param_real_array_1d = upper_bound_constrain(p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = upper_bound_constrain(p_real_array_1d, p_real); + transformed_param_real_array_1d = upper_bound_constrain(p_real_array_1d, p_real_array_1d); + transformed_param_real_array_2d = upper_bound_constrain(d_real_array_2d, d_real); + transformed_param_real_array_2d = upper_bound_constrain(d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = upper_bound_constrain(d_real_array_2d, p_real); + transformed_param_real_array_2d = upper_bound_constrain(d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = upper_bound_constrain(p_real_array_2d, d_real); + transformed_param_real_array_2d = upper_bound_constrain(p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = upper_bound_constrain(p_real_array_2d, p_real); + transformed_param_real_array_2d = upper_bound_constrain(p_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = upper_bound_constrain(d_real_array_3d, d_real); + transformed_param_real_array_3d = upper_bound_constrain(d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = upper_bound_constrain(d_real_array_3d, p_real); + transformed_param_real_array_3d = upper_bound_constrain(d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = upper_bound_constrain(p_real_array_3d, d_real); + transformed_param_real_array_3d = upper_bound_constrain(p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = upper_bound_constrain(p_real_array_3d, p_real); + transformed_param_real_array_3d = upper_bound_constrain(p_real_array_3d, p_real_array_3d); + transformed_param_row_vector = upper_bound_constrain(d_row_vector, d_real); + transformed_param_row_vector = upper_bound_constrain(d_row_vector, d_row_vector); + transformed_param_row_vector = upper_bound_constrain(d_row_vector, p_real); + transformed_param_row_vector = upper_bound_constrain(d_row_vector, p_row_vector); + transformed_param_row_vector = upper_bound_constrain(p_row_vector, d_real); + transformed_param_row_vector = upper_bound_constrain(p_row_vector, d_row_vector); + transformed_param_row_vector = upper_bound_constrain(p_row_vector, p_real); + transformed_param_row_vector = upper_bound_constrain(p_row_vector, p_row_vector); + transformed_param_row_vector_array_1d = upper_bound_constrain(d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = upper_bound_constrain(d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = upper_bound_constrain(d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = upper_bound_constrain(d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = upper_bound_constrain(p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = upper_bound_constrain(p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = upper_bound_constrain(p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = upper_bound_constrain(p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = upper_bound_constrain(d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = upper_bound_constrain(d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = upper_bound_constrain(d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = upper_bound_constrain(d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = upper_bound_constrain(p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = upper_bound_constrain(p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = upper_bound_constrain(p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = upper_bound_constrain(p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = upper_bound_constrain(d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = upper_bound_constrain(d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = upper_bound_constrain(d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = upper_bound_constrain(d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = upper_bound_constrain(p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = upper_bound_constrain(p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = upper_bound_constrain(p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = upper_bound_constrain(p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_vector = upper_bound_constrain(d_vector, d_real); + transformed_param_vector = upper_bound_constrain(d_vector, d_vector); + transformed_param_vector = upper_bound_constrain(d_vector, p_real); + transformed_param_vector = upper_bound_constrain(d_vector, p_vector); + transformed_param_vector = upper_bound_constrain(p_vector, d_real); + transformed_param_vector = upper_bound_constrain(p_vector, d_vector); + transformed_param_vector = upper_bound_constrain(p_vector, p_real); + transformed_param_vector = upper_bound_constrain(p_vector, p_vector); + transformed_param_vector_array_1d = upper_bound_constrain(d_vector_array_1d, d_real); + transformed_param_vector_array_1d = upper_bound_constrain(d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = upper_bound_constrain(d_vector_array_1d, p_real); + transformed_param_vector_array_1d = upper_bound_constrain(d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = upper_bound_constrain(p_vector_array_1d, d_real); + transformed_param_vector_array_1d = upper_bound_constrain(p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = upper_bound_constrain(p_vector_array_1d, p_real); + transformed_param_vector_array_1d = upper_bound_constrain(p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_2d = upper_bound_constrain(d_vector_array_2d, d_real); + transformed_param_vector_array_2d = upper_bound_constrain(d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = upper_bound_constrain(d_vector_array_2d, p_real); + transformed_param_vector_array_2d = upper_bound_constrain(d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = upper_bound_constrain(p_vector_array_2d, d_real); + transformed_param_vector_array_2d = upper_bound_constrain(p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = upper_bound_constrain(p_vector_array_2d, p_real); + transformed_param_vector_array_2d = upper_bound_constrain(p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_3d = upper_bound_constrain(d_vector_array_3d, d_real); + transformed_param_vector_array_3d = upper_bound_constrain(d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = upper_bound_constrain(d_vector_array_3d, p_real); + transformed_param_vector_array_3d = upper_bound_constrain(d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = upper_bound_constrain(p_vector_array_3d, d_real); + transformed_param_vector_array_3d = upper_bound_constrain(p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = upper_bound_constrain(p_vector_array_3d, p_real); + transformed_param_vector_array_3d = upper_bound_constrain(p_vector_array_3d, p_vector_array_3d); +} + diff --git a/test/integration/good/function-signatures/math/transforms/upper_bound_jacobian.stan b/test/integration/good/function-signatures/math/transforms/upper_bound_jacobian.stan new file mode 100644 index 0000000000..e413640523 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/upper_bound_jacobian.stan @@ -0,0 +1,198 @@ +data { + int d_int; + array[d_int] int d_int_array; + array[d_int, 2] int d_int_array_2d; + array[d_int, 2, 3] int d_int_array_3d; + real d_real; + array[d_int] real d_real_array; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + matrix[d_int, d_int] d_matrix; + array[d_int] matrix[d_int, d_int] d_matrix_array; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + vector[d_int] d_vector; + array[d_int] vector[d_int] d_vector_array; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + row_vector[d_int] d_row_vector; + array[d_int] row_vector[d_int] d_row_vector_array; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; +} + +parameters { + real p_real; + array[d_int] real p_real_array; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + matrix[d_int, d_int] p_matrix; + array[d_int] matrix[d_int, d_int] p_matrix_array; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + vector[d_int] p_vector; + array[d_int] vector[d_int] p_vector_array; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + row_vector[d_int] p_row_vector; + array[d_int] row_vector[d_int] p_row_vector_array; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + real y_p; +} +transformed parameters { + real transformed_real; + array[d_int] real transformed_param_array; + array[d_int, 2] real transformed_param_array_2d; + array[d_int, 2, 3] real transformed_param_array_3d; + matrix[d_int, d_int] transformed_param_matrix; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + vector[d_int] transformed_param_vector; + array[d_int] vector[d_int] transformed_param_vector_array; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + row_vector[d_int] transformed_param_row_vector; + array[d_int] row_vector[d_int] transformed_param_row_vector_array; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_real = upper_bound_jacobian(d_real, d_real); + transformed_real = upper_bound_jacobian(d_real, p_real); + transformed_real = upper_bound_jacobian(p_real, d_real); + transformed_real = upper_bound_jacobian(p_real, p_real); + + transformed_param_array_2d = upper_bound_jacobian(p_real_array_2d, d_real); + transformed_param_array_2d = upper_bound_jacobian(p_real_array_2d, p_real); + transformed_param_array_2d = upper_bound_jacobian(d_real_array_2d, p_real); + transformed_param_array_2d = upper_bound_jacobian(d_real_array_2d, d_real); + transformed_param_array_3d = upper_bound_jacobian(d_real_array_3d, d_real); + transformed_param_array_3d = upper_bound_jacobian(p_real_array_3d, d_real); + transformed_param_array_3d = upper_bound_jacobian(p_real_array_3d, p_real); + transformed_param_array_3d = upper_bound_jacobian(d_real_array_3d, p_real); + + + transformed_param_array = upper_bound_jacobian(d_real_array, d_real_array); + transformed_param_array = upper_bound_jacobian(d_real_array, p_real_array); + transformed_param_array = upper_bound_jacobian(p_real_array, d_real_array); + transformed_param_array = upper_bound_jacobian(p_real_array, p_real_array); + transformed_param_array_2d = upper_bound_jacobian(d_real_array_2d, p_real_array_2d); + transformed_param_array_2d = upper_bound_jacobian(p_real_array_2d, d_real_array_2d); + transformed_param_array_2d = upper_bound_jacobian(p_real_array_2d, p_real_array_2d); + transformed_param_array_3d = upper_bound_jacobian(d_real_array_3d, p_real_array_3d); + transformed_param_array_3d = upper_bound_jacobian(p_real_array_3d, d_real_array_3d); + transformed_param_array_3d = upper_bound_jacobian(p_real_array_3d, p_real_array_3d); + + transformed_param_vector = upper_bound_jacobian(p_vector, p_real); + transformed_param_vector = upper_bound_jacobian(p_vector, d_real); + transformed_param_vector = upper_bound_jacobian(d_vector, p_real); + transformed_param_vector_array = upper_bound_jacobian(p_vector_array, p_real); + transformed_param_vector_array = upper_bound_jacobian(p_vector_array, d_real); + transformed_param_vector_array = upper_bound_jacobian(d_vector_array, p_real); + transformed_param_vector_array_2d = upper_bound_jacobian(p_vector_array_2d, p_real); + transformed_param_vector_array_2d = upper_bound_jacobian(p_vector_array_2d, d_real); + transformed_param_vector_array_2d = upper_bound_jacobian(d_vector_array_2d, p_real); + transformed_param_vector_array_3d = upper_bound_jacobian(p_vector_array_3d, p_real); + transformed_param_vector_array_3d = upper_bound_jacobian(p_vector_array_3d, d_real); + transformed_param_vector_array_3d = upper_bound_jacobian(d_vector_array_3d, p_real); + + transformed_param_vector = upper_bound_jacobian(p_vector, p_vector); + transformed_param_vector = upper_bound_jacobian(p_vector, d_vector); + transformed_param_vector = upper_bound_jacobian(d_vector, p_vector); + transformed_param_vector_array = upper_bound_jacobian(p_vector_array, p_vector_array); + transformed_param_vector_array = upper_bound_jacobian(p_vector_array, d_vector_array); + transformed_param_vector_array = upper_bound_jacobian(d_vector_array, p_vector_array); + transformed_param_vector_array_2d = upper_bound_jacobian(p_vector_array_2d, + p_vector_array_2d); + transformed_param_vector_array_2d = upper_bound_jacobian(p_vector_array_2d, + d_vector_array_2d); + transformed_param_vector_array_2d = upper_bound_jacobian(d_vector_array_2d, + p_vector_array_2d); + transformed_param_vector_array_3d = upper_bound_jacobian(p_vector_array_3d, + p_vector_array_3d); + transformed_param_vector_array_3d = upper_bound_jacobian(p_vector_array_3d, + d_vector_array_3d); + transformed_param_vector_array_3d = upper_bound_jacobian(d_vector_array_3d, + p_vector_array_3d); + + transformed_param_row_vector = upper_bound_jacobian(p_row_vector, p_real); + transformed_param_row_vector = upper_bound_jacobian(p_row_vector, d_real); + transformed_param_row_vector = upper_bound_jacobian(d_row_vector, p_real); + transformed_param_row_vector_array = upper_bound_jacobian(p_row_vector_array, p_real); + transformed_param_row_vector_array = upper_bound_jacobian(p_row_vector_array, d_real); + transformed_param_row_vector_array = upper_bound_jacobian(d_row_vector_array, p_real); + transformed_param_row_vector_array_2d = upper_bound_jacobian(p_row_vector_array_2d, + p_real); + transformed_param_row_vector_array_2d = upper_bound_jacobian(p_row_vector_array_2d, + d_real); + transformed_param_row_vector_array_2d = upper_bound_jacobian(d_row_vector_array_2d, + p_real); + transformed_param_row_vector_array_3d = upper_bound_jacobian(p_row_vector_array_3d, + p_real); + transformed_param_row_vector_array_3d = upper_bound_jacobian(p_row_vector_array_3d, + d_real); + transformed_param_row_vector_array_3d = upper_bound_jacobian(d_row_vector_array_3d, + p_real); + + + + transformed_param_row_vector = upper_bound_jacobian(p_row_vector, p_row_vector); + transformed_param_row_vector = upper_bound_jacobian(p_row_vector, d_row_vector); + transformed_param_row_vector = upper_bound_jacobian(d_row_vector, p_row_vector); + transformed_param_row_vector_array = upper_bound_jacobian(p_row_vector_array, + p_row_vector_array); + transformed_param_row_vector_array = upper_bound_jacobian(p_row_vector_array, + d_row_vector_array); + transformed_param_row_vector_array = upper_bound_jacobian(d_row_vector_array, + p_row_vector_array); + transformed_param_row_vector_array_2d = upper_bound_jacobian(p_row_vector_array_2d, + p_row_vector_array_2d); + transformed_param_row_vector_array_2d = upper_bound_jacobian(p_row_vector_array_2d, + d_row_vector_array_2d); + transformed_param_row_vector_array_2d = upper_bound_jacobian(d_row_vector_array_2d, + p_row_vector_array_2d); + transformed_param_row_vector_array_3d = upper_bound_jacobian(p_row_vector_array_3d, + p_row_vector_array_3d); + transformed_param_row_vector_array_3d = upper_bound_jacobian(p_row_vector_array_3d, + d_row_vector_array_3d); + transformed_param_row_vector_array_3d = upper_bound_jacobian(d_row_vector_array_3d, + p_row_vector_array_3d); + + transformed_param_matrix = upper_bound_jacobian(p_matrix, p_real); + transformed_param_matrix = upper_bound_jacobian(p_matrix, d_real); + transformed_param_matrix = upper_bound_jacobian(d_matrix, p_real); + transformed_param_matrix_array = upper_bound_jacobian(p_matrix_array, p_real); + transformed_param_matrix_array = upper_bound_jacobian(p_matrix_array, d_real); + transformed_param_matrix_array = upper_bound_jacobian(d_matrix_array, p_real); + transformed_param_matrix_array_2d = upper_bound_jacobian(p_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = upper_bound_jacobian(p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = upper_bound_jacobian(d_matrix_array_2d, p_real); + transformed_param_matrix_array_3d = upper_bound_jacobian(p_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = upper_bound_jacobian(p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = upper_bound_jacobian(d_matrix_array_3d, p_real); + + + transformed_param_matrix = upper_bound_jacobian(p_matrix, p_matrix); + transformed_param_matrix = upper_bound_jacobian(p_matrix, d_matrix); + transformed_param_matrix = upper_bound_jacobian(d_matrix, p_matrix); + transformed_param_matrix_array = upper_bound_jacobian(p_matrix_array, p_matrix_array); + transformed_param_matrix_array = upper_bound_jacobian(p_matrix_array, d_matrix_array); + transformed_param_matrix_array = upper_bound_jacobian(d_matrix_array, p_matrix_array); + transformed_param_matrix_array_2d = upper_bound_jacobian(p_matrix_array_2d, + p_matrix_array_2d); + transformed_param_matrix_array_2d = upper_bound_jacobian(p_matrix_array_2d, + d_matrix_array_2d); + transformed_param_matrix_array_2d = upper_bound_jacobian(d_matrix_array_2d, + p_matrix_array_2d); + transformed_param_matrix_array_3d = upper_bound_jacobian(p_matrix_array_3d, + p_matrix_array_3d); + transformed_param_matrix_array_3d = upper_bound_jacobian(p_matrix_array_3d, + d_matrix_array_3d); + transformed_param_matrix_array_3d = upper_bound_jacobian(d_matrix_array_3d, + p_matrix_array_3d); +} +model { + y_p ~ normal(0, 1); +} + diff --git a/test/integration/good/function-signatures/math/transforms/upper_bound_unconstrain.stan b/test/integration/good/function-signatures/math/transforms/upper_bound_unconstrain.stan new file mode 100644 index 0000000000..bc78222181 --- /dev/null +++ b/test/integration/good/function-signatures/math/transforms/upper_bound_unconstrain.stan @@ -0,0 +1,239 @@ +data { + int d_int; + real d_real; + vector[d_int] d_vector; + matrix[d_int, d_int] d_matrix; + row_vector[d_int] d_row_vector; + array[d_int] real d_real_array_1d; + array[d_int, 2] real d_real_array_2d; + array[d_int, 2, 3] real d_real_array_3d; + array[d_int] vector[d_int] d_vector_array_1d; + array[d_int, 2] vector[d_int] d_vector_array_2d; + array[d_int, 2, 3] vector[d_int] d_vector_array_3d; + array[d_int] matrix[d_int, d_int] d_matrix_array_1d; + array[d_int] row_vector[d_int] d_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] d_matrix_array_2d; + array[d_int, 2] row_vector[d_int] d_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] d_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] d_row_vector_array_3d; + + +} + +transformed data { + int td_int; + real td_real; + vector[d_int] td_vector; + matrix[d_int, d_int] td_matrix; + row_vector[d_int] td_row_vector; + array[d_int] real td_real_array_1d; + array[d_int, 2] real td_real_array_2d; + array[d_int, 2, 3] real td_real_array_3d; + array[d_int] vector[d_int] td_vector_array_1d; + array[d_int, 2] vector[d_int] td_vector_array_2d; + array[d_int, 2, 3] vector[d_int] td_vector_array_3d; + array[d_int] matrix[d_int, d_int] td_matrix_array_1d; + array[d_int] row_vector[d_int] td_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] td_matrix_array_2d; + array[d_int, 2] row_vector[d_int] td_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] td_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] td_row_vector_array_3d; + + td_matrix = upper_bound_unconstrain(d_matrix, d_matrix); + td_matrix = upper_bound_unconstrain(d_matrix, d_real); + td_matrix_array_1d = upper_bound_unconstrain(d_matrix_array_1d, d_matrix_array_1d); + td_matrix_array_1d = upper_bound_unconstrain(d_matrix_array_1d, d_real); + td_matrix_array_2d = upper_bound_unconstrain(d_matrix_array_2d, d_matrix_array_2d); + td_matrix_array_2d = upper_bound_unconstrain(d_matrix_array_2d, d_real); + td_matrix_array_3d = upper_bound_unconstrain(d_matrix_array_3d, d_matrix_array_3d); + td_matrix_array_3d = upper_bound_unconstrain(d_matrix_array_3d, d_real); + td_real = upper_bound_unconstrain(d_real, d_real); + td_real_array_1d = upper_bound_unconstrain(d_real_array_1d, d_real); + td_real_array_1d = upper_bound_unconstrain(d_real_array_1d, d_real_array_1d); + td_real_array_2d = upper_bound_unconstrain(d_real_array_2d, d_real); + td_real_array_2d = upper_bound_unconstrain(d_real_array_2d, d_real_array_2d); + td_real_array_3d = upper_bound_unconstrain(d_real_array_3d, d_real); + td_real_array_3d = upper_bound_unconstrain(d_real_array_3d, d_real_array_3d); + td_row_vector = upper_bound_unconstrain(d_row_vector, d_real); + td_row_vector = upper_bound_unconstrain(d_row_vector, d_row_vector); + td_row_vector_array_1d = upper_bound_unconstrain(d_row_vector_array_1d, d_real); + td_row_vector_array_1d = upper_bound_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d); + td_row_vector_array_2d = upper_bound_unconstrain(d_row_vector_array_2d, d_real); + td_row_vector_array_2d = upper_bound_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d); + td_row_vector_array_3d = upper_bound_unconstrain(d_row_vector_array_3d, d_real); + td_row_vector_array_3d = upper_bound_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d); + td_vector = upper_bound_unconstrain(d_vector, d_real); + td_vector = upper_bound_unconstrain(d_vector, d_vector); + td_vector_array_1d = upper_bound_unconstrain(d_vector_array_1d, d_real); + td_vector_array_1d = upper_bound_unconstrain(d_vector_array_1d, d_vector_array_1d); + td_vector_array_2d = upper_bound_unconstrain(d_vector_array_2d, d_real); + td_vector_array_2d = upper_bound_unconstrain(d_vector_array_2d, d_vector_array_2d); + td_vector_array_3d = upper_bound_unconstrain(d_vector_array_3d, d_real); + td_vector_array_3d = upper_bound_unconstrain(d_vector_array_3d, d_vector_array_3d); +} + +parameters { + real p_real; + vector[d_int] p_vector; + matrix[d_int, d_int] p_matrix; + row_vector[d_int] p_row_vector; + array[d_int] real p_real_array_1d; + array[d_int, 2] real p_real_array_2d; + array[d_int, 2, 3] real p_real_array_3d; + array[d_int] vector[d_int] p_vector_array_1d; + array[d_int, 2] vector[d_int] p_vector_array_2d; + array[d_int, 2, 3] vector[d_int] p_vector_array_3d; + array[d_int] matrix[d_int, d_int] p_matrix_array_1d; + array[d_int] row_vector[d_int] p_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] p_matrix_array_2d; + array[d_int, 2] row_vector[d_int] p_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] p_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] p_row_vector_array_3d; + + +} + +transformed parameters { + real transformed_param_real; + vector[d_int] transformed_param_vector; + matrix[d_int, d_int] transformed_param_matrix; + row_vector[d_int] transformed_param_row_vector; + array[d_int] real transformed_param_real_array_1d; + array[d_int, 2] real transformed_param_real_array_2d; + array[d_int, 2, 3] real transformed_param_real_array_3d; + array[d_int] vector[d_int] transformed_param_vector_array_1d; + array[d_int, 2] vector[d_int] transformed_param_vector_array_2d; + array[d_int, 2, 3] vector[d_int] transformed_param_vector_array_3d; + array[d_int] matrix[d_int, d_int] transformed_param_matrix_array_1d; + array[d_int] row_vector[d_int] transformed_param_row_vector_array_1d; + array[d_int, 2] matrix[d_int, d_int] transformed_param_matrix_array_2d; + array[d_int, 2] row_vector[d_int] transformed_param_row_vector_array_2d; + array[d_int, 2, 3] matrix[d_int, d_int] transformed_param_matrix_array_3d; + array[d_int, 2, 3] row_vector[d_int] transformed_param_row_vector_array_3d; + + transformed_param_matrix = upper_bound_unconstrain(d_matrix, d_matrix); + transformed_param_matrix = upper_bound_unconstrain(d_matrix, d_real); + transformed_param_matrix = upper_bound_unconstrain(d_matrix, p_matrix); + transformed_param_matrix = upper_bound_unconstrain(d_matrix, p_real); + transformed_param_matrix = upper_bound_unconstrain(p_matrix, d_matrix); + transformed_param_matrix = upper_bound_unconstrain(p_matrix, d_real); + transformed_param_matrix = upper_bound_unconstrain(p_matrix, p_matrix); + transformed_param_matrix = upper_bound_unconstrain(p_matrix, p_real); + transformed_param_matrix_array_1d = upper_bound_unconstrain(d_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = upper_bound_unconstrain(d_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = upper_bound_unconstrain(d_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = upper_bound_unconstrain(d_matrix_array_1d, p_real); + transformed_param_matrix_array_1d = upper_bound_unconstrain(p_matrix_array_1d, d_matrix_array_1d); + transformed_param_matrix_array_1d = upper_bound_unconstrain(p_matrix_array_1d, d_real); + transformed_param_matrix_array_1d = upper_bound_unconstrain(p_matrix_array_1d, p_matrix_array_1d); + transformed_param_matrix_array_1d = upper_bound_unconstrain(p_matrix_array_1d, p_real); + transformed_param_matrix_array_2d = upper_bound_unconstrain(d_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = upper_bound_unconstrain(d_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = upper_bound_unconstrain(d_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = upper_bound_unconstrain(d_matrix_array_2d, p_real); + transformed_param_matrix_array_2d = upper_bound_unconstrain(p_matrix_array_2d, d_matrix_array_2d); + transformed_param_matrix_array_2d = upper_bound_unconstrain(p_matrix_array_2d, d_real); + transformed_param_matrix_array_2d = upper_bound_unconstrain(p_matrix_array_2d, p_matrix_array_2d); + transformed_param_matrix_array_2d = upper_bound_unconstrain(p_matrix_array_2d, p_real); + transformed_param_matrix_array_3d = upper_bound_unconstrain(d_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = upper_bound_unconstrain(d_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = upper_bound_unconstrain(d_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = upper_bound_unconstrain(d_matrix_array_3d, p_real); + transformed_param_matrix_array_3d = upper_bound_unconstrain(p_matrix_array_3d, d_matrix_array_3d); + transformed_param_matrix_array_3d = upper_bound_unconstrain(p_matrix_array_3d, d_real); + transformed_param_matrix_array_3d = upper_bound_unconstrain(p_matrix_array_3d, p_matrix_array_3d); + transformed_param_matrix_array_3d = upper_bound_unconstrain(p_matrix_array_3d, p_real); + transformed_param_real = upper_bound_unconstrain(d_real, d_real); + transformed_param_real = upper_bound_unconstrain(d_real, p_real); + transformed_param_real = upper_bound_unconstrain(p_real, d_real); + transformed_param_real = upper_bound_unconstrain(p_real, p_real); + transformed_param_real_array_1d = upper_bound_unconstrain(d_real_array_1d, d_real); + transformed_param_real_array_1d = upper_bound_unconstrain(d_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = upper_bound_unconstrain(d_real_array_1d, p_real); + transformed_param_real_array_1d = upper_bound_unconstrain(d_real_array_1d, p_real_array_1d); + transformed_param_real_array_1d = upper_bound_unconstrain(p_real_array_1d, d_real); + transformed_param_real_array_1d = upper_bound_unconstrain(p_real_array_1d, d_real_array_1d); + transformed_param_real_array_1d = upper_bound_unconstrain(p_real_array_1d, p_real); + transformed_param_real_array_1d = upper_bound_unconstrain(p_real_array_1d, p_real_array_1d); + transformed_param_real_array_2d = upper_bound_unconstrain(d_real_array_2d, d_real); + transformed_param_real_array_2d = upper_bound_unconstrain(d_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = upper_bound_unconstrain(d_real_array_2d, p_real); + transformed_param_real_array_2d = upper_bound_unconstrain(d_real_array_2d, p_real_array_2d); + transformed_param_real_array_2d = upper_bound_unconstrain(p_real_array_2d, d_real); + transformed_param_real_array_2d = upper_bound_unconstrain(p_real_array_2d, d_real_array_2d); + transformed_param_real_array_2d = upper_bound_unconstrain(p_real_array_2d, p_real); + transformed_param_real_array_2d = upper_bound_unconstrain(p_real_array_2d, p_real_array_2d); + transformed_param_real_array_3d = upper_bound_unconstrain(d_real_array_3d, d_real); + transformed_param_real_array_3d = upper_bound_unconstrain(d_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = upper_bound_unconstrain(d_real_array_3d, p_real); + transformed_param_real_array_3d = upper_bound_unconstrain(d_real_array_3d, p_real_array_3d); + transformed_param_real_array_3d = upper_bound_unconstrain(p_real_array_3d, d_real); + transformed_param_real_array_3d = upper_bound_unconstrain(p_real_array_3d, d_real_array_3d); + transformed_param_real_array_3d = upper_bound_unconstrain(p_real_array_3d, p_real); + transformed_param_real_array_3d = upper_bound_unconstrain(p_real_array_3d, p_real_array_3d); + transformed_param_row_vector = upper_bound_unconstrain(d_row_vector, d_real); + transformed_param_row_vector = upper_bound_unconstrain(d_row_vector, d_row_vector); + transformed_param_row_vector = upper_bound_unconstrain(d_row_vector, p_real); + transformed_param_row_vector = upper_bound_unconstrain(d_row_vector, p_row_vector); + transformed_param_row_vector = upper_bound_unconstrain(p_row_vector, d_real); + transformed_param_row_vector = upper_bound_unconstrain(p_row_vector, d_row_vector); + transformed_param_row_vector = upper_bound_unconstrain(p_row_vector, p_real); + transformed_param_row_vector = upper_bound_unconstrain(p_row_vector, p_row_vector); + transformed_param_row_vector_array_1d = upper_bound_unconstrain(d_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = upper_bound_unconstrain(d_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = upper_bound_unconstrain(d_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = upper_bound_unconstrain(d_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_1d = upper_bound_unconstrain(p_row_vector_array_1d, d_real); + transformed_param_row_vector_array_1d = upper_bound_unconstrain(p_row_vector_array_1d, d_row_vector_array_1d); + transformed_param_row_vector_array_1d = upper_bound_unconstrain(p_row_vector_array_1d, p_real); + transformed_param_row_vector_array_1d = upper_bound_unconstrain(p_row_vector_array_1d, p_row_vector_array_1d); + transformed_param_row_vector_array_2d = upper_bound_unconstrain(d_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = upper_bound_unconstrain(d_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = upper_bound_unconstrain(d_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = upper_bound_unconstrain(d_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_2d = upper_bound_unconstrain(p_row_vector_array_2d, d_real); + transformed_param_row_vector_array_2d = upper_bound_unconstrain(p_row_vector_array_2d, d_row_vector_array_2d); + transformed_param_row_vector_array_2d = upper_bound_unconstrain(p_row_vector_array_2d, p_real); + transformed_param_row_vector_array_2d = upper_bound_unconstrain(p_row_vector_array_2d, p_row_vector_array_2d); + transformed_param_row_vector_array_3d = upper_bound_unconstrain(d_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = upper_bound_unconstrain(d_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = upper_bound_unconstrain(d_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = upper_bound_unconstrain(d_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_row_vector_array_3d = upper_bound_unconstrain(p_row_vector_array_3d, d_real); + transformed_param_row_vector_array_3d = upper_bound_unconstrain(p_row_vector_array_3d, d_row_vector_array_3d); + transformed_param_row_vector_array_3d = upper_bound_unconstrain(p_row_vector_array_3d, p_real); + transformed_param_row_vector_array_3d = upper_bound_unconstrain(p_row_vector_array_3d, p_row_vector_array_3d); + transformed_param_vector = upper_bound_unconstrain(d_vector, d_real); + transformed_param_vector = upper_bound_unconstrain(d_vector, d_vector); + transformed_param_vector = upper_bound_unconstrain(d_vector, p_real); + transformed_param_vector = upper_bound_unconstrain(d_vector, p_vector); + transformed_param_vector = upper_bound_unconstrain(p_vector, d_real); + transformed_param_vector = upper_bound_unconstrain(p_vector, d_vector); + transformed_param_vector = upper_bound_unconstrain(p_vector, p_real); + transformed_param_vector = upper_bound_unconstrain(p_vector, p_vector); + transformed_param_vector_array_1d = upper_bound_unconstrain(d_vector_array_1d, d_real); + transformed_param_vector_array_1d = upper_bound_unconstrain(d_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = upper_bound_unconstrain(d_vector_array_1d, p_real); + transformed_param_vector_array_1d = upper_bound_unconstrain(d_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_1d = upper_bound_unconstrain(p_vector_array_1d, d_real); + transformed_param_vector_array_1d = upper_bound_unconstrain(p_vector_array_1d, d_vector_array_1d); + transformed_param_vector_array_1d = upper_bound_unconstrain(p_vector_array_1d, p_real); + transformed_param_vector_array_1d = upper_bound_unconstrain(p_vector_array_1d, p_vector_array_1d); + transformed_param_vector_array_2d = upper_bound_unconstrain(d_vector_array_2d, d_real); + transformed_param_vector_array_2d = upper_bound_unconstrain(d_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = upper_bound_unconstrain(d_vector_array_2d, p_real); + transformed_param_vector_array_2d = upper_bound_unconstrain(d_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_2d = upper_bound_unconstrain(p_vector_array_2d, d_real); + transformed_param_vector_array_2d = upper_bound_unconstrain(p_vector_array_2d, d_vector_array_2d); + transformed_param_vector_array_2d = upper_bound_unconstrain(p_vector_array_2d, p_real); + transformed_param_vector_array_2d = upper_bound_unconstrain(p_vector_array_2d, p_vector_array_2d); + transformed_param_vector_array_3d = upper_bound_unconstrain(d_vector_array_3d, d_real); + transformed_param_vector_array_3d = upper_bound_unconstrain(d_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = upper_bound_unconstrain(d_vector_array_3d, p_real); + transformed_param_vector_array_3d = upper_bound_unconstrain(d_vector_array_3d, p_vector_array_3d); + transformed_param_vector_array_3d = upper_bound_unconstrain(p_vector_array_3d, d_real); + transformed_param_vector_array_3d = upper_bound_unconstrain(p_vector_array_3d, d_vector_array_3d); + transformed_param_vector_array_3d = upper_bound_unconstrain(p_vector_array_3d, p_real); + transformed_param_vector_array_3d = upper_bound_unconstrain(p_vector_array_3d, p_vector_array_3d); +} + diff --git a/test/integration/good/warning/data_jacobian.stan b/test/integration/good/warning/data_jacobian.stan new file mode 100644 index 0000000000..466850f0e6 --- /dev/null +++ b/test/integration/good/warning/data_jacobian.stan @@ -0,0 +1,16 @@ +functions { + real my_upper_bound_jacobian(real x, real ub) { + jacobian += x; + return ub - exp(x); + } +} + +data { + real beta_raw; + real ub; +} + +transformed parameters { + real beta = upper_bound_jacobian(beta_raw, ub); + real beta2 = my_upper_bound_jacobian(beta_raw, ub); +} diff --git a/test/integration/good/warning/pretty.expected b/test/integration/good/warning/pretty.expected index 25ee296bf3..713e943407 100644 --- a/test/integration/good/warning/pretty.expected +++ b/test/integration/good/warning/pretty.expected @@ -1,3 +1,27 @@ + $ ../../../../../install/default/bin/stanc --auto-format data_jacobian.stan +functions { + real my_upper_bound_jacobian(real x, real ub) { + jacobian += x; + return ub - exp(x); + } +} +data { + real beta_raw; + real ub; +} +transformed parameters { + real beta = upper_bound_jacobian(beta_raw, ub); + real beta2 = my_upper_bound_jacobian(beta_raw, ub); +} + +Warning in 'data_jacobian.stan', line 14, column 14: Calling a _jacobian + function without any parameter arguments still applies the Jacobian + adjustments, ensure this is intentional! Consider using + upper_bound_constrain instead. +Warning in 'data_jacobian.stan', line 15, column 15: Calling a _jacobian + function without any parameter arguments still applies the Jacobian + adjustments, ensure this is intentional! +[exit 0] $ ../../../../../install/default/bin/stanc --auto-format deprecated_syntax.stan functions { real jacobian(real x, int y) { diff --git a/test/integration/signatures/stan_math_signatures.t b/test/integration/signatures/stan_math_signatures.t index bdfef6a79f..0ef9fcca35 100644 --- a/test/integration/signatures/stan_math_signatures.t +++ b/test/integration/signatures/stan_math_signatures.t @@ -3421,6 +3421,54 @@ Display all Stan math signatures exposed in the language chi_square_rng(array[] real) => array[] real chol2inv(matrix) => matrix cholesky_decompose(matrix) => matrix + cholesky_factor_corr_constrain(vector, int) => matrix + cholesky_factor_corr_constrain(array[] vector, int) => array[] matrix + cholesky_factor_corr_constrain(array[,] vector, int) => array[,] matrix + cholesky_factor_corr_constrain(array[,,] vector, int) => array[,,] matrix + cholesky_factor_corr_constrain(array[,,,] vector, int) => array[,,,] matrix + cholesky_factor_corr_constrain(array[,,,,] vector, int) => array[,,,,] matrix + cholesky_factor_corr_constrain(array[,,,,,] vector, int) => array[,,,,,] matrix + cholesky_factor_corr_constrain(array[,,,,,,] vector, int) => array[,,,,,,] matrix + cholesky_factor_corr_jacobian(vector, int) => matrix + cholesky_factor_corr_jacobian(array[] vector, int) => array[] matrix + cholesky_factor_corr_jacobian(array[,] vector, int) => array[,] matrix + cholesky_factor_corr_jacobian(array[,,] vector, int) => array[,,] matrix + cholesky_factor_corr_jacobian(array[,,,] vector, int) => array[,,,] matrix + cholesky_factor_corr_jacobian(array[,,,,] vector, int) => array[,,,,] matrix + cholesky_factor_corr_jacobian(array[,,,,,] vector, int) => array[,,,,,] matrix + cholesky_factor_corr_jacobian(array[,,,,,,] vector, int) => array[,,,,,,] matrix + cholesky_factor_corr_unconstrain(matrix) => vector + cholesky_factor_corr_unconstrain(array[] matrix) => array[] vector + cholesky_factor_corr_unconstrain(array[,] matrix) => array[,] vector + cholesky_factor_corr_unconstrain(array[,,] matrix) => array[,,] vector + cholesky_factor_corr_unconstrain(array[,,,] matrix) => array[,,,] vector + cholesky_factor_corr_unconstrain(array[,,,,] matrix) => array[,,,,] vector + cholesky_factor_corr_unconstrain(array[,,,,,] matrix) => array[,,,,,] vector + cholesky_factor_corr_unconstrain(array[,,,,,,] matrix) => array[,,,,,,] vector + cholesky_factor_cov_constrain(vector, int, int) => matrix + cholesky_factor_cov_constrain(array[] vector, int, int) => array[] matrix + cholesky_factor_cov_constrain(array[,] vector, int, int) => array[,] matrix + cholesky_factor_cov_constrain(array[,,] vector, int, int) => array[,,] matrix + cholesky_factor_cov_constrain(array[,,,] vector, int, int) => array[,,,] matrix + cholesky_factor_cov_constrain(array[,,,,] vector, int, int) => array[,,,,] matrix + cholesky_factor_cov_constrain(array[,,,,,] vector, int, int) => array[,,,,,] matrix + cholesky_factor_cov_constrain(array[,,,,,,] vector, int, int) => array[,,,,,,] matrix + cholesky_factor_cov_jacobian(vector, int, int) => matrix + cholesky_factor_cov_jacobian(array[] vector, int, int) => array[] matrix + cholesky_factor_cov_jacobian(array[,] vector, int, int) => array[,] matrix + cholesky_factor_cov_jacobian(array[,,] vector, int, int) => array[,,] matrix + cholesky_factor_cov_jacobian(array[,,,] vector, int, int) => array[,,,] matrix + cholesky_factor_cov_jacobian(array[,,,,] vector, int, int) => array[,,,,] matrix + cholesky_factor_cov_jacobian(array[,,,,,] vector, int, int) => array[,,,,,] matrix + cholesky_factor_cov_jacobian(array[,,,,,,] vector, int, int) => array[,,,,,,] matrix + cholesky_factor_cov_unconstrain(matrix) => vector + cholesky_factor_cov_unconstrain(array[] matrix) => array[] vector + cholesky_factor_cov_unconstrain(array[,] matrix) => array[,] vector + cholesky_factor_cov_unconstrain(array[,,] matrix) => array[,,] vector + cholesky_factor_cov_unconstrain(array[,,,] matrix) => array[,,,] vector + cholesky_factor_cov_unconstrain(array[,,,,] matrix) => array[,,,,] vector + cholesky_factor_cov_unconstrain(array[,,,,,] matrix) => array[,,,,,] vector + cholesky_factor_cov_unconstrain(array[,,,,,,] matrix) => array[,,,,,,] vector choose(int, int) => int choose(int, array[] int) => array[] int choose(int, array[,] int) => array[,] int @@ -3501,6 +3549,30 @@ Display all Stan math signatures exposed in the language conj(array[,,,,,,] complex_vector) => array[,,,,,,] complex_vector conj(array[,,,,,,] complex_row_vector) => array[,,,,,,] complex_row_vector conj(array[,,,,,,] complex_matrix) => array[,,,,,,] complex_matrix + corr_matrix_constrain(vector, int) => matrix + corr_matrix_constrain(array[] vector, int) => array[] matrix + corr_matrix_constrain(array[,] vector, int) => array[,] matrix + corr_matrix_constrain(array[,,] vector, int) => array[,,] matrix + corr_matrix_constrain(array[,,,] vector, int) => array[,,,] matrix + corr_matrix_constrain(array[,,,,] vector, int) => array[,,,,] matrix + corr_matrix_constrain(array[,,,,,] vector, int) => array[,,,,,] matrix + corr_matrix_constrain(array[,,,,,,] vector, int) => array[,,,,,,] matrix + corr_matrix_jacobian(vector, int) => matrix + corr_matrix_jacobian(array[] vector, int) => array[] matrix + corr_matrix_jacobian(array[,] vector, int) => array[,] matrix + corr_matrix_jacobian(array[,,] vector, int) => array[,,] matrix + corr_matrix_jacobian(array[,,,] vector, int) => array[,,,] matrix + corr_matrix_jacobian(array[,,,,] vector, int) => array[,,,,] matrix + corr_matrix_jacobian(array[,,,,,] vector, int) => array[,,,,,] matrix + corr_matrix_jacobian(array[,,,,,,] vector, int) => array[,,,,,,] matrix + corr_matrix_unconstrain(matrix) => vector + corr_matrix_unconstrain(array[] matrix) => array[] vector + corr_matrix_unconstrain(array[,] matrix) => array[,] vector + corr_matrix_unconstrain(array[,,] matrix) => array[,,] vector + corr_matrix_unconstrain(array[,,,] matrix) => array[,,,] vector + corr_matrix_unconstrain(array[,,,,] matrix) => array[,,,,] vector + corr_matrix_unconstrain(array[,,,,,] matrix) => array[,,,,,] vector + corr_matrix_unconstrain(array[,,,,,,] matrix) => array[,,,,,,] vector cos(int) => real cos(real) => real cos(vector) => vector @@ -3583,6 +3655,30 @@ Display all Stan math signatures exposed in the language cosh(array[,,,,,,] vector) => array[,,,,,,] vector cosh(array[,,,,,,] row_vector) => array[,,,,,,] row_vector cosh(array[,,,,,,] matrix) => array[,,,,,,] matrix + cov_matrix_constrain(vector, int) => matrix + cov_matrix_constrain(array[] vector, int) => array[] matrix + cov_matrix_constrain(array[,] vector, int) => array[,] matrix + cov_matrix_constrain(array[,,] vector, int) => array[,,] matrix + cov_matrix_constrain(array[,,,] vector, int) => array[,,,] matrix + cov_matrix_constrain(array[,,,,] vector, int) => array[,,,,] matrix + cov_matrix_constrain(array[,,,,,] vector, int) => array[,,,,,] matrix + cov_matrix_constrain(array[,,,,,,] vector, int) => array[,,,,,,] matrix + cov_matrix_jacobian(vector, int) => matrix + cov_matrix_jacobian(array[] vector, int) => array[] matrix + cov_matrix_jacobian(array[,] vector, int) => array[,] matrix + cov_matrix_jacobian(array[,,] vector, int) => array[,,] matrix + cov_matrix_jacobian(array[,,,] vector, int) => array[,,,] matrix + cov_matrix_jacobian(array[,,,,] vector, int) => array[,,,,] matrix + cov_matrix_jacobian(array[,,,,,] vector, int) => array[,,,,,] matrix + cov_matrix_jacobian(array[,,,,,,] vector, int) => array[,,,,,,] matrix + cov_matrix_unconstrain(matrix) => vector + cov_matrix_unconstrain(array[] matrix) => array[] vector + cov_matrix_unconstrain(array[,] matrix) => array[,] vector + cov_matrix_unconstrain(array[,,] matrix) => array[,,] vector + cov_matrix_unconstrain(array[,,,] matrix) => array[,,,] vector + cov_matrix_unconstrain(array[,,,,] matrix) => array[,,,,] vector + cov_matrix_unconstrain(array[,,,,,] matrix) => array[,,,,,] vector + cov_matrix_unconstrain(array[,,,,,,] matrix) => array[,,,,,,] vector crossprod(matrix) => matrix csr_extract(matrix) => tuple(vector, array[] int, array[] int) csr_extract_u(matrix) => array[] int @@ -12038,6 +12134,492 @@ Display all Stan math signatures exposed in the language lognormal_rng(array[] real, row_vector) => array[] real lognormal_rng(array[] real, array[] int) => array[] real lognormal_rng(array[] real, array[] real) => array[] real + lower_bound_constrain(real, real) => real + lower_bound_constrain(vector, real) => vector + lower_bound_constrain(vector, vector) => vector + lower_bound_constrain(row_vector, real) => row_vector + lower_bound_constrain(row_vector, row_vector) => row_vector + lower_bound_constrain(matrix, real) => matrix + lower_bound_constrain(matrix, matrix) => matrix + lower_bound_constrain(array[] real, real) => array[] real + lower_bound_constrain(array[] real, array[] real) => array[] real + lower_bound_constrain(array[] vector, real) => array[] vector + lower_bound_constrain(array[] vector, array[] vector) => array[] vector + lower_bound_constrain(array[] row_vector, real) => array[] row_vector + lower_bound_constrain(array[] row_vector, array[] row_vector) => array[] row_vector + lower_bound_constrain(array[] matrix, real) => array[] matrix + lower_bound_constrain(array[] matrix, array[] matrix) => array[] matrix + lower_bound_constrain(array[,] real, real) => array[,] real + lower_bound_constrain(array[,] real, array[,] real) => array[,] real + lower_bound_constrain(array[,] vector, real) => array[,] vector + lower_bound_constrain(array[,] vector, array[,] vector) => array[,] vector + lower_bound_constrain(array[,] row_vector, real) => array[,] row_vector + lower_bound_constrain(array[,] row_vector, array[,] row_vector) => array[,] row_vector + lower_bound_constrain(array[,] matrix, real) => array[,] matrix + lower_bound_constrain(array[,] matrix, array[,] matrix) => array[,] matrix + lower_bound_constrain(array[,,] real, real) => array[,,] real + lower_bound_constrain(array[,,] real, array[,,] real) => array[,,] real + lower_bound_constrain(array[,,] vector, real) => array[,,] vector + lower_bound_constrain(array[,,] vector, array[,,] vector) => array[,,] vector + lower_bound_constrain(array[,,] row_vector, real) => array[,,] row_vector + lower_bound_constrain(array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + lower_bound_constrain(array[,,] matrix, real) => array[,,] matrix + lower_bound_constrain(array[,,] matrix, array[,,] matrix) => array[,,] matrix + lower_bound_constrain(array[,,,] real, real) => array[,,,] real + lower_bound_constrain(array[,,,] real, array[,,,] real) => array[,,,] real + lower_bound_constrain(array[,,,] vector, real) => array[,,,] vector + lower_bound_constrain(array[,,,] vector, array[,,,] vector) => array[,,,] vector + lower_bound_constrain(array[,,,] row_vector, real) => array[,,,] row_vector + lower_bound_constrain(array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + lower_bound_constrain(array[,,,] matrix, real) => array[,,,] matrix + lower_bound_constrain(array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + lower_bound_constrain(array[,,,,] real, real) => array[,,,,] real + lower_bound_constrain(array[,,,,] real, array[,,,,] real) => array[,,,,] real + lower_bound_constrain(array[,,,,] vector, real) => array[,,,,] vector + lower_bound_constrain(array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + lower_bound_constrain(array[,,,,] row_vector, real) => array[,,,,] row_vector + lower_bound_constrain(array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + lower_bound_constrain(array[,,,,] matrix, real) => array[,,,,] matrix + lower_bound_constrain(array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + lower_bound_constrain(array[,,,,,] real, real) => array[,,,,,] real + lower_bound_constrain(array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + lower_bound_constrain(array[,,,,,] vector, real) => array[,,,,,] vector + lower_bound_constrain(array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + lower_bound_constrain(array[,,,,,] row_vector, real) => array[,,,,,] row_vector + lower_bound_constrain(array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + lower_bound_constrain(array[,,,,,] matrix, real) => array[,,,,,] matrix + lower_bound_constrain(array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + lower_bound_constrain(array[,,,,,,] real, real) => array[,,,,,,] real + lower_bound_constrain(array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + lower_bound_constrain(array[,,,,,,] vector, real) => array[,,,,,,] vector + lower_bound_constrain(array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + lower_bound_constrain(array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + lower_bound_constrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + lower_bound_constrain(array[,,,,,,] matrix, real) => array[,,,,,,] matrix + lower_bound_constrain(array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + lower_bound_constrain(array[,,,,,,,] real, real) => array[,,,,,,,] real + lower_bound_constrain(array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real + lower_bound_jacobian(real, real) => real + lower_bound_jacobian(vector, real) => vector + lower_bound_jacobian(vector, vector) => vector + lower_bound_jacobian(row_vector, real) => row_vector + lower_bound_jacobian(row_vector, row_vector) => row_vector + lower_bound_jacobian(matrix, real) => matrix + lower_bound_jacobian(matrix, matrix) => matrix + lower_bound_jacobian(array[] real, real) => array[] real + lower_bound_jacobian(array[] real, array[] real) => array[] real + lower_bound_jacobian(array[] vector, real) => array[] vector + lower_bound_jacobian(array[] vector, array[] vector) => array[] vector + lower_bound_jacobian(array[] row_vector, real) => array[] row_vector + lower_bound_jacobian(array[] row_vector, array[] row_vector) => array[] row_vector + lower_bound_jacobian(array[] matrix, real) => array[] matrix + lower_bound_jacobian(array[] matrix, array[] matrix) => array[] matrix + lower_bound_jacobian(array[,] real, real) => array[,] real + lower_bound_jacobian(array[,] real, array[,] real) => array[,] real + lower_bound_jacobian(array[,] vector, real) => array[,] vector + lower_bound_jacobian(array[,] vector, array[,] vector) => array[,] vector + lower_bound_jacobian(array[,] row_vector, real) => array[,] row_vector + lower_bound_jacobian(array[,] row_vector, array[,] row_vector) => array[,] row_vector + lower_bound_jacobian(array[,] matrix, real) => array[,] matrix + lower_bound_jacobian(array[,] matrix, array[,] matrix) => array[,] matrix + lower_bound_jacobian(array[,,] real, real) => array[,,] real + lower_bound_jacobian(array[,,] real, array[,,] real) => array[,,] real + lower_bound_jacobian(array[,,] vector, real) => array[,,] vector + lower_bound_jacobian(array[,,] vector, array[,,] vector) => array[,,] vector + lower_bound_jacobian(array[,,] row_vector, real) => array[,,] row_vector + lower_bound_jacobian(array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + lower_bound_jacobian(array[,,] matrix, real) => array[,,] matrix + lower_bound_jacobian(array[,,] matrix, array[,,] matrix) => array[,,] matrix + lower_bound_jacobian(array[,,,] real, real) => array[,,,] real + lower_bound_jacobian(array[,,,] real, array[,,,] real) => array[,,,] real + lower_bound_jacobian(array[,,,] vector, real) => array[,,,] vector + lower_bound_jacobian(array[,,,] vector, array[,,,] vector) => array[,,,] vector + lower_bound_jacobian(array[,,,] row_vector, real) => array[,,,] row_vector + lower_bound_jacobian(array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + lower_bound_jacobian(array[,,,] matrix, real) => array[,,,] matrix + lower_bound_jacobian(array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + lower_bound_jacobian(array[,,,,] real, real) => array[,,,,] real + lower_bound_jacobian(array[,,,,] real, array[,,,,] real) => array[,,,,] real + lower_bound_jacobian(array[,,,,] vector, real) => array[,,,,] vector + lower_bound_jacobian(array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + lower_bound_jacobian(array[,,,,] row_vector, real) => array[,,,,] row_vector + lower_bound_jacobian(array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + lower_bound_jacobian(array[,,,,] matrix, real) => array[,,,,] matrix + lower_bound_jacobian(array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + lower_bound_jacobian(array[,,,,,] real, real) => array[,,,,,] real + lower_bound_jacobian(array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + lower_bound_jacobian(array[,,,,,] vector, real) => array[,,,,,] vector + lower_bound_jacobian(array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + lower_bound_jacobian(array[,,,,,] row_vector, real) => array[,,,,,] row_vector + lower_bound_jacobian(array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + lower_bound_jacobian(array[,,,,,] matrix, real) => array[,,,,,] matrix + lower_bound_jacobian(array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + lower_bound_jacobian(array[,,,,,,] real, real) => array[,,,,,,] real + lower_bound_jacobian(array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + lower_bound_jacobian(array[,,,,,,] vector, real) => array[,,,,,,] vector + lower_bound_jacobian(array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + lower_bound_jacobian(array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + lower_bound_jacobian(array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + lower_bound_jacobian(array[,,,,,,] matrix, real) => array[,,,,,,] matrix + lower_bound_jacobian(array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + lower_bound_jacobian(array[,,,,,,,] real, real) => array[,,,,,,,] real + lower_bound_jacobian(array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real + lower_bound_unconstrain(real, real) => real + lower_bound_unconstrain(vector, real) => vector + lower_bound_unconstrain(vector, vector) => vector + lower_bound_unconstrain(row_vector, real) => row_vector + lower_bound_unconstrain(row_vector, row_vector) => row_vector + lower_bound_unconstrain(matrix, real) => matrix + lower_bound_unconstrain(matrix, matrix) => matrix + lower_bound_unconstrain(array[] real, real) => array[] real + lower_bound_unconstrain(array[] real, array[] real) => array[] real + lower_bound_unconstrain(array[] vector, real) => array[] vector + lower_bound_unconstrain(array[] vector, array[] vector) => array[] vector + lower_bound_unconstrain(array[] row_vector, real) => array[] row_vector + lower_bound_unconstrain(array[] row_vector, array[] row_vector) => array[] row_vector + lower_bound_unconstrain(array[] matrix, real) => array[] matrix + lower_bound_unconstrain(array[] matrix, array[] matrix) => array[] matrix + lower_bound_unconstrain(array[,] real, real) => array[,] real + lower_bound_unconstrain(array[,] real, array[,] real) => array[,] real + lower_bound_unconstrain(array[,] vector, real) => array[,] vector + lower_bound_unconstrain(array[,] vector, array[,] vector) => array[,] vector + lower_bound_unconstrain(array[,] row_vector, real) => array[,] row_vector + lower_bound_unconstrain(array[,] row_vector, array[,] row_vector) => array[,] row_vector + lower_bound_unconstrain(array[,] matrix, real) => array[,] matrix + lower_bound_unconstrain(array[,] matrix, array[,] matrix) => array[,] matrix + lower_bound_unconstrain(array[,,] real, real) => array[,,] real + lower_bound_unconstrain(array[,,] real, array[,,] real) => array[,,] real + lower_bound_unconstrain(array[,,] vector, real) => array[,,] vector + lower_bound_unconstrain(array[,,] vector, array[,,] vector) => array[,,] vector + lower_bound_unconstrain(array[,,] row_vector, real) => array[,,] row_vector + lower_bound_unconstrain(array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + lower_bound_unconstrain(array[,,] matrix, real) => array[,,] matrix + lower_bound_unconstrain(array[,,] matrix, array[,,] matrix) => array[,,] matrix + lower_bound_unconstrain(array[,,,] real, real) => array[,,,] real + lower_bound_unconstrain(array[,,,] real, array[,,,] real) => array[,,,] real + lower_bound_unconstrain(array[,,,] vector, real) => array[,,,] vector + lower_bound_unconstrain(array[,,,] vector, array[,,,] vector) => array[,,,] vector + lower_bound_unconstrain(array[,,,] row_vector, real) => array[,,,] row_vector + lower_bound_unconstrain(array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + lower_bound_unconstrain(array[,,,] matrix, real) => array[,,,] matrix + lower_bound_unconstrain(array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + lower_bound_unconstrain(array[,,,,] real, real) => array[,,,,] real + lower_bound_unconstrain(array[,,,,] real, array[,,,,] real) => array[,,,,] real + lower_bound_unconstrain(array[,,,,] vector, real) => array[,,,,] vector + lower_bound_unconstrain(array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + lower_bound_unconstrain(array[,,,,] row_vector, real) => array[,,,,] row_vector + lower_bound_unconstrain(array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + lower_bound_unconstrain(array[,,,,] matrix, real) => array[,,,,] matrix + lower_bound_unconstrain(array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + lower_bound_unconstrain(array[,,,,,] real, real) => array[,,,,,] real + lower_bound_unconstrain(array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + lower_bound_unconstrain(array[,,,,,] vector, real) => array[,,,,,] vector + lower_bound_unconstrain(array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + lower_bound_unconstrain(array[,,,,,] row_vector, real) => array[,,,,,] row_vector + lower_bound_unconstrain(array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + lower_bound_unconstrain(array[,,,,,] matrix, real) => array[,,,,,] matrix + lower_bound_unconstrain(array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + lower_bound_unconstrain(array[,,,,,,] real, real) => array[,,,,,,] real + lower_bound_unconstrain(array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + lower_bound_unconstrain(array[,,,,,,] vector, real) => array[,,,,,,] vector + lower_bound_unconstrain(array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + lower_bound_unconstrain(array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + lower_bound_unconstrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + lower_bound_unconstrain(array[,,,,,,] matrix, real) => array[,,,,,,] matrix + lower_bound_unconstrain(array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + lower_bound_unconstrain(array[,,,,,,,] real, real) => array[,,,,,,,] real + lower_bound_unconstrain(array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real + lower_upper_bound_constrain(real, real, real) => real + lower_upper_bound_constrain(vector, real, vector) => vector + lower_upper_bound_constrain(vector, vector, real) => vector + lower_upper_bound_constrain(vector, vector, vector) => vector + lower_upper_bound_constrain(row_vector, real, row_vector) => row_vector + lower_upper_bound_constrain(row_vector, row_vector, real) => row_vector + lower_upper_bound_constrain(row_vector, row_vector, row_vector) => row_vector + lower_upper_bound_constrain(matrix, real, matrix) => matrix + lower_upper_bound_constrain(matrix, matrix, real) => matrix + lower_upper_bound_constrain(matrix, matrix, matrix) => matrix + lower_upper_bound_constrain(array[] real, real, array[] real) => array[] real + lower_upper_bound_constrain(array[] real, array[] real, real) => array[] real + lower_upper_bound_constrain(array[] real, array[] real, array[] real) => array[] real + lower_upper_bound_constrain(array[] vector, real, array[] vector) => array[] vector + lower_upper_bound_constrain(array[] vector, array[] vector, real) => array[] vector + lower_upper_bound_constrain(array[] vector, array[] vector, array[] vector) => array[] vector + lower_upper_bound_constrain(array[] row_vector, real, array[] row_vector) => array[] row_vector + lower_upper_bound_constrain(array[] row_vector, array[] row_vector, real) => array[] row_vector + lower_upper_bound_constrain(array[] row_vector, array[] row_vector, array[] row_vector) => array[] row_vector + lower_upper_bound_constrain(array[] matrix, real, array[] matrix) => array[] matrix + lower_upper_bound_constrain(array[] matrix, array[] matrix, real) => array[] matrix + lower_upper_bound_constrain(array[] matrix, array[] matrix, array[] matrix) => array[] matrix + lower_upper_bound_constrain(array[,] real, real, array[,] real) => array[,] real + lower_upper_bound_constrain(array[,] real, array[,] real, real) => array[,] real + lower_upper_bound_constrain(array[,] real, array[,] real, array[,] real) => array[,] real + lower_upper_bound_constrain(array[,] vector, real, array[,] vector) => array[,] vector + lower_upper_bound_constrain(array[,] vector, array[,] vector, real) => array[,] vector + lower_upper_bound_constrain(array[,] vector, array[,] vector, array[,] vector) => array[,] vector + lower_upper_bound_constrain(array[,] row_vector, real, array[,] row_vector) => array[,] row_vector + lower_upper_bound_constrain(array[,] row_vector, array[,] row_vector, real) => array[,] row_vector + lower_upper_bound_constrain(array[,] row_vector, array[,] row_vector, array[,] row_vector) => array[,] row_vector + lower_upper_bound_constrain(array[,] matrix, real, array[,] matrix) => array[,] matrix + lower_upper_bound_constrain(array[,] matrix, array[,] matrix, real) => array[,] matrix + lower_upper_bound_constrain(array[,] matrix, array[,] matrix, array[,] matrix) => array[,] matrix + lower_upper_bound_constrain(array[,,] real, real, array[,,] real) => array[,,] real + lower_upper_bound_constrain(array[,,] real, array[,,] real, real) => array[,,] real + lower_upper_bound_constrain(array[,,] real, array[,,] real, array[,,] real) => array[,,] real + lower_upper_bound_constrain(array[,,] vector, real, array[,,] vector) => array[,,] vector + lower_upper_bound_constrain(array[,,] vector, array[,,] vector, real) => array[,,] vector + lower_upper_bound_constrain(array[,,] vector, array[,,] vector, array[,,] vector) => array[,,] vector + lower_upper_bound_constrain(array[,,] row_vector, real, array[,,] row_vector) => array[,,] row_vector + lower_upper_bound_constrain(array[,,] row_vector, array[,,] row_vector, real) => array[,,] row_vector + lower_upper_bound_constrain(array[,,] row_vector, array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + lower_upper_bound_constrain(array[,,] matrix, real, array[,,] matrix) => array[,,] matrix + lower_upper_bound_constrain(array[,,] matrix, array[,,] matrix, real) => array[,,] matrix + lower_upper_bound_constrain(array[,,] matrix, array[,,] matrix, array[,,] matrix) => array[,,] matrix + lower_upper_bound_constrain(array[,,,] real, real, array[,,,] real) => array[,,,] real + lower_upper_bound_constrain(array[,,,] real, array[,,,] real, real) => array[,,,] real + lower_upper_bound_constrain(array[,,,] real, array[,,,] real, array[,,,] real) => array[,,,] real + lower_upper_bound_constrain(array[,,,] vector, real, array[,,,] vector) => array[,,,] vector + lower_upper_bound_constrain(array[,,,] vector, array[,,,] vector, real) => array[,,,] vector + lower_upper_bound_constrain(array[,,,] vector, array[,,,] vector, array[,,,] vector) => array[,,,] vector + lower_upper_bound_constrain(array[,,,] row_vector, real, array[,,,] row_vector) => array[,,,] row_vector + lower_upper_bound_constrain(array[,,,] row_vector, array[,,,] row_vector, real) => array[,,,] row_vector + lower_upper_bound_constrain(array[,,,] row_vector, array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + lower_upper_bound_constrain(array[,,,] matrix, real, array[,,,] matrix) => array[,,,] matrix + lower_upper_bound_constrain(array[,,,] matrix, array[,,,] matrix, real) => array[,,,] matrix + lower_upper_bound_constrain(array[,,,] matrix, array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + lower_upper_bound_constrain(array[,,,,] real, real, array[,,,,] real) => array[,,,,] real + lower_upper_bound_constrain(array[,,,,] real, array[,,,,] real, real) => array[,,,,] real + lower_upper_bound_constrain(array[,,,,] real, array[,,,,] real, array[,,,,] real) => array[,,,,] real + lower_upper_bound_constrain(array[,,,,] vector, real, array[,,,,] vector) => array[,,,,] vector + lower_upper_bound_constrain(array[,,,,] vector, array[,,,,] vector, real) => array[,,,,] vector + lower_upper_bound_constrain(array[,,,,] vector, array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + lower_upper_bound_constrain(array[,,,,] row_vector, real, array[,,,,] row_vector) => array[,,,,] row_vector + lower_upper_bound_constrain(array[,,,,] row_vector, array[,,,,] row_vector, real) => array[,,,,] row_vector + lower_upper_bound_constrain(array[,,,,] row_vector, array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + lower_upper_bound_constrain(array[,,,,] matrix, real, array[,,,,] matrix) => array[,,,,] matrix + lower_upper_bound_constrain(array[,,,,] matrix, array[,,,,] matrix, real) => array[,,,,] matrix + lower_upper_bound_constrain(array[,,,,] matrix, array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + lower_upper_bound_constrain(array[,,,,,] real, real, array[,,,,,] real) => array[,,,,,] real + lower_upper_bound_constrain(array[,,,,,] real, array[,,,,,] real, real) => array[,,,,,] real + lower_upper_bound_constrain(array[,,,,,] real, array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + lower_upper_bound_constrain(array[,,,,,] vector, real, array[,,,,,] vector) => array[,,,,,] vector + lower_upper_bound_constrain(array[,,,,,] vector, array[,,,,,] vector, real) => array[,,,,,] vector + lower_upper_bound_constrain(array[,,,,,] vector, array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + lower_upper_bound_constrain(array[,,,,,] row_vector, real, array[,,,,,] row_vector) => array[,,,,,] row_vector + lower_upper_bound_constrain(array[,,,,,] row_vector, array[,,,,,] row_vector, real) => array[,,,,,] row_vector + lower_upper_bound_constrain(array[,,,,,] row_vector, array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + lower_upper_bound_constrain(array[,,,,,] matrix, real, array[,,,,,] matrix) => array[,,,,,] matrix + lower_upper_bound_constrain(array[,,,,,] matrix, array[,,,,,] matrix, real) => array[,,,,,] matrix + lower_upper_bound_constrain(array[,,,,,] matrix, array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + lower_upper_bound_constrain(array[,,,,,,] real, real, array[,,,,,,] real) => array[,,,,,,] real + lower_upper_bound_constrain(array[,,,,,,] real, array[,,,,,,] real, real) => array[,,,,,,] real + lower_upper_bound_constrain(array[,,,,,,] real, array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + lower_upper_bound_constrain(array[,,,,,,] vector, real, array[,,,,,,] vector) => array[,,,,,,] vector + lower_upper_bound_constrain(array[,,,,,,] vector, array[,,,,,,] vector, real) => array[,,,,,,] vector + lower_upper_bound_constrain(array[,,,,,,] vector, array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + lower_upper_bound_constrain(array[,,,,,,] row_vector, real, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + lower_upper_bound_constrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + lower_upper_bound_constrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + lower_upper_bound_constrain(array[,,,,,,] matrix, real, array[,,,,,,] matrix) => array[,,,,,,] matrix + lower_upper_bound_constrain(array[,,,,,,] matrix, array[,,,,,,] matrix, real) => array[,,,,,,] matrix + lower_upper_bound_constrain(array[,,,,,,] matrix, array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + lower_upper_bound_constrain(array[,,,,,,,] real, real, array[,,,,,,,] real) => array[,,,,,,,] real + lower_upper_bound_constrain(array[,,,,,,,] real, array[,,,,,,,] real, real) => array[,,,,,,,] real + lower_upper_bound_constrain(array[,,,,,,,] real, array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real + lower_upper_bound_jacobian(real, real, real) => real + lower_upper_bound_jacobian(vector, real, vector) => vector + lower_upper_bound_jacobian(vector, vector, real) => vector + lower_upper_bound_jacobian(vector, vector, vector) => vector + lower_upper_bound_jacobian(row_vector, real, row_vector) => row_vector + lower_upper_bound_jacobian(row_vector, row_vector, real) => row_vector + lower_upper_bound_jacobian(row_vector, row_vector, row_vector) => row_vector + lower_upper_bound_jacobian(matrix, real, matrix) => matrix + lower_upper_bound_jacobian(matrix, matrix, real) => matrix + lower_upper_bound_jacobian(matrix, matrix, matrix) => matrix + lower_upper_bound_jacobian(array[] real, real, array[] real) => array[] real + lower_upper_bound_jacobian(array[] real, array[] real, real) => array[] real + lower_upper_bound_jacobian(array[] real, array[] real, array[] real) => array[] real + lower_upper_bound_jacobian(array[] vector, real, array[] vector) => array[] vector + lower_upper_bound_jacobian(array[] vector, array[] vector, real) => array[] vector + lower_upper_bound_jacobian(array[] vector, array[] vector, array[] vector) => array[] vector + lower_upper_bound_jacobian(array[] row_vector, real, array[] row_vector) => array[] row_vector + lower_upper_bound_jacobian(array[] row_vector, array[] row_vector, real) => array[] row_vector + lower_upper_bound_jacobian(array[] row_vector, array[] row_vector, array[] row_vector) => array[] row_vector + lower_upper_bound_jacobian(array[] matrix, real, array[] matrix) => array[] matrix + lower_upper_bound_jacobian(array[] matrix, array[] matrix, real) => array[] matrix + lower_upper_bound_jacobian(array[] matrix, array[] matrix, array[] matrix) => array[] matrix + lower_upper_bound_jacobian(array[,] real, real, array[,] real) => array[,] real + lower_upper_bound_jacobian(array[,] real, array[,] real, real) => array[,] real + lower_upper_bound_jacobian(array[,] real, array[,] real, array[,] real) => array[,] real + lower_upper_bound_jacobian(array[,] vector, real, array[,] vector) => array[,] vector + lower_upper_bound_jacobian(array[,] vector, array[,] vector, real) => array[,] vector + lower_upper_bound_jacobian(array[,] vector, array[,] vector, array[,] vector) => array[,] vector + lower_upper_bound_jacobian(array[,] row_vector, real, array[,] row_vector) => array[,] row_vector + lower_upper_bound_jacobian(array[,] row_vector, array[,] row_vector, real) => array[,] row_vector + lower_upper_bound_jacobian(array[,] row_vector, array[,] row_vector, array[,] row_vector) => array[,] row_vector + lower_upper_bound_jacobian(array[,] matrix, real, array[,] matrix) => array[,] matrix + lower_upper_bound_jacobian(array[,] matrix, array[,] matrix, real) => array[,] matrix + lower_upper_bound_jacobian(array[,] matrix, array[,] matrix, array[,] matrix) => array[,] matrix + lower_upper_bound_jacobian(array[,,] real, real, array[,,] real) => array[,,] real + lower_upper_bound_jacobian(array[,,] real, array[,,] real, real) => array[,,] real + lower_upper_bound_jacobian(array[,,] real, array[,,] real, array[,,] real) => array[,,] real + lower_upper_bound_jacobian(array[,,] vector, real, array[,,] vector) => array[,,] vector + lower_upper_bound_jacobian(array[,,] vector, array[,,] vector, real) => array[,,] vector + lower_upper_bound_jacobian(array[,,] vector, array[,,] vector, array[,,] vector) => array[,,] vector + lower_upper_bound_jacobian(array[,,] row_vector, real, array[,,] row_vector) => array[,,] row_vector + lower_upper_bound_jacobian(array[,,] row_vector, array[,,] row_vector, real) => array[,,] row_vector + lower_upper_bound_jacobian(array[,,] row_vector, array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + lower_upper_bound_jacobian(array[,,] matrix, real, array[,,] matrix) => array[,,] matrix + lower_upper_bound_jacobian(array[,,] matrix, array[,,] matrix, real) => array[,,] matrix + lower_upper_bound_jacobian(array[,,] matrix, array[,,] matrix, array[,,] matrix) => array[,,] matrix + lower_upper_bound_jacobian(array[,,,] real, real, array[,,,] real) => array[,,,] real + lower_upper_bound_jacobian(array[,,,] real, array[,,,] real, real) => array[,,,] real + lower_upper_bound_jacobian(array[,,,] real, array[,,,] real, array[,,,] real) => array[,,,] real + lower_upper_bound_jacobian(array[,,,] vector, real, array[,,,] vector) => array[,,,] vector + lower_upper_bound_jacobian(array[,,,] vector, array[,,,] vector, real) => array[,,,] vector + lower_upper_bound_jacobian(array[,,,] vector, array[,,,] vector, array[,,,] vector) => array[,,,] vector + lower_upper_bound_jacobian(array[,,,] row_vector, real, array[,,,] row_vector) => array[,,,] row_vector + lower_upper_bound_jacobian(array[,,,] row_vector, array[,,,] row_vector, real) => array[,,,] row_vector + lower_upper_bound_jacobian(array[,,,] row_vector, array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + lower_upper_bound_jacobian(array[,,,] matrix, real, array[,,,] matrix) => array[,,,] matrix + lower_upper_bound_jacobian(array[,,,] matrix, array[,,,] matrix, real) => array[,,,] matrix + lower_upper_bound_jacobian(array[,,,] matrix, array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + lower_upper_bound_jacobian(array[,,,,] real, real, array[,,,,] real) => array[,,,,] real + lower_upper_bound_jacobian(array[,,,,] real, array[,,,,] real, real) => array[,,,,] real + lower_upper_bound_jacobian(array[,,,,] real, array[,,,,] real, array[,,,,] real) => array[,,,,] real + lower_upper_bound_jacobian(array[,,,,] vector, real, array[,,,,] vector) => array[,,,,] vector + lower_upper_bound_jacobian(array[,,,,] vector, array[,,,,] vector, real) => array[,,,,] vector + lower_upper_bound_jacobian(array[,,,,] vector, array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + lower_upper_bound_jacobian(array[,,,,] row_vector, real, array[,,,,] row_vector) => array[,,,,] row_vector + lower_upper_bound_jacobian(array[,,,,] row_vector, array[,,,,] row_vector, real) => array[,,,,] row_vector + lower_upper_bound_jacobian(array[,,,,] row_vector, array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + lower_upper_bound_jacobian(array[,,,,] matrix, real, array[,,,,] matrix) => array[,,,,] matrix + lower_upper_bound_jacobian(array[,,,,] matrix, array[,,,,] matrix, real) => array[,,,,] matrix + lower_upper_bound_jacobian(array[,,,,] matrix, array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + lower_upper_bound_jacobian(array[,,,,,] real, real, array[,,,,,] real) => array[,,,,,] real + lower_upper_bound_jacobian(array[,,,,,] real, array[,,,,,] real, real) => array[,,,,,] real + lower_upper_bound_jacobian(array[,,,,,] real, array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + lower_upper_bound_jacobian(array[,,,,,] vector, real, array[,,,,,] vector) => array[,,,,,] vector + lower_upper_bound_jacobian(array[,,,,,] vector, array[,,,,,] vector, real) => array[,,,,,] vector + lower_upper_bound_jacobian(array[,,,,,] vector, array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + lower_upper_bound_jacobian(array[,,,,,] row_vector, real, array[,,,,,] row_vector) => array[,,,,,] row_vector + lower_upper_bound_jacobian(array[,,,,,] row_vector, array[,,,,,] row_vector, real) => array[,,,,,] row_vector + lower_upper_bound_jacobian(array[,,,,,] row_vector, array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + lower_upper_bound_jacobian(array[,,,,,] matrix, real, array[,,,,,] matrix) => array[,,,,,] matrix + lower_upper_bound_jacobian(array[,,,,,] matrix, array[,,,,,] matrix, real) => array[,,,,,] matrix + lower_upper_bound_jacobian(array[,,,,,] matrix, array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + lower_upper_bound_jacobian(array[,,,,,,] real, real, array[,,,,,,] real) => array[,,,,,,] real + lower_upper_bound_jacobian(array[,,,,,,] real, array[,,,,,,] real, real) => array[,,,,,,] real + lower_upper_bound_jacobian(array[,,,,,,] real, array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + lower_upper_bound_jacobian(array[,,,,,,] vector, real, array[,,,,,,] vector) => array[,,,,,,] vector + lower_upper_bound_jacobian(array[,,,,,,] vector, array[,,,,,,] vector, real) => array[,,,,,,] vector + lower_upper_bound_jacobian(array[,,,,,,] vector, array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + lower_upper_bound_jacobian(array[,,,,,,] row_vector, real, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + lower_upper_bound_jacobian(array[,,,,,,] row_vector, array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + lower_upper_bound_jacobian(array[,,,,,,] row_vector, array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + lower_upper_bound_jacobian(array[,,,,,,] matrix, real, array[,,,,,,] matrix) => array[,,,,,,] matrix + lower_upper_bound_jacobian(array[,,,,,,] matrix, array[,,,,,,] matrix, real) => array[,,,,,,] matrix + lower_upper_bound_jacobian(array[,,,,,,] matrix, array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + lower_upper_bound_jacobian(array[,,,,,,,] real, real, array[,,,,,,,] real) => array[,,,,,,,] real + lower_upper_bound_jacobian(array[,,,,,,,] real, array[,,,,,,,] real, real) => array[,,,,,,,] real + lower_upper_bound_jacobian(array[,,,,,,,] real, array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real + lower_upper_bound_unconstrain(real, real, real) => real + lower_upper_bound_unconstrain(vector, real, vector) => vector + lower_upper_bound_unconstrain(vector, vector, real) => vector + lower_upper_bound_unconstrain(vector, vector, vector) => vector + lower_upper_bound_unconstrain(row_vector, real, row_vector) => row_vector + lower_upper_bound_unconstrain(row_vector, row_vector, real) => row_vector + lower_upper_bound_unconstrain(row_vector, row_vector, row_vector) => row_vector + lower_upper_bound_unconstrain(matrix, real, matrix) => matrix + lower_upper_bound_unconstrain(matrix, matrix, real) => matrix + lower_upper_bound_unconstrain(matrix, matrix, matrix) => matrix + lower_upper_bound_unconstrain(array[] real, real, array[] real) => array[] real + lower_upper_bound_unconstrain(array[] real, array[] real, real) => array[] real + lower_upper_bound_unconstrain(array[] real, array[] real, array[] real) => array[] real + lower_upper_bound_unconstrain(array[] vector, real, array[] vector) => array[] vector + lower_upper_bound_unconstrain(array[] vector, array[] vector, real) => array[] vector + lower_upper_bound_unconstrain(array[] vector, array[] vector, array[] vector) => array[] vector + lower_upper_bound_unconstrain(array[] row_vector, real, array[] row_vector) => array[] row_vector + lower_upper_bound_unconstrain(array[] row_vector, array[] row_vector, real) => array[] row_vector + lower_upper_bound_unconstrain(array[] row_vector, array[] row_vector, array[] row_vector) => array[] row_vector + lower_upper_bound_unconstrain(array[] matrix, real, array[] matrix) => array[] matrix + lower_upper_bound_unconstrain(array[] matrix, array[] matrix, real) => array[] matrix + lower_upper_bound_unconstrain(array[] matrix, array[] matrix, array[] matrix) => array[] matrix + lower_upper_bound_unconstrain(array[,] real, real, array[,] real) => array[,] real + lower_upper_bound_unconstrain(array[,] real, array[,] real, real) => array[,] real + lower_upper_bound_unconstrain(array[,] real, array[,] real, array[,] real) => array[,] real + lower_upper_bound_unconstrain(array[,] vector, real, array[,] vector) => array[,] vector + lower_upper_bound_unconstrain(array[,] vector, array[,] vector, real) => array[,] vector + lower_upper_bound_unconstrain(array[,] vector, array[,] vector, array[,] vector) => array[,] vector + lower_upper_bound_unconstrain(array[,] row_vector, real, array[,] row_vector) => array[,] row_vector + lower_upper_bound_unconstrain(array[,] row_vector, array[,] row_vector, real) => array[,] row_vector + lower_upper_bound_unconstrain(array[,] row_vector, array[,] row_vector, array[,] row_vector) => array[,] row_vector + lower_upper_bound_unconstrain(array[,] matrix, real, array[,] matrix) => array[,] matrix + lower_upper_bound_unconstrain(array[,] matrix, array[,] matrix, real) => array[,] matrix + lower_upper_bound_unconstrain(array[,] matrix, array[,] matrix, array[,] matrix) => array[,] matrix + lower_upper_bound_unconstrain(array[,,] real, real, array[,,] real) => array[,,] real + lower_upper_bound_unconstrain(array[,,] real, array[,,] real, real) => array[,,] real + lower_upper_bound_unconstrain(array[,,] real, array[,,] real, array[,,] real) => array[,,] real + lower_upper_bound_unconstrain(array[,,] vector, real, array[,,] vector) => array[,,] vector + lower_upper_bound_unconstrain(array[,,] vector, array[,,] vector, real) => array[,,] vector + lower_upper_bound_unconstrain(array[,,] vector, array[,,] vector, array[,,] vector) => array[,,] vector + lower_upper_bound_unconstrain(array[,,] row_vector, real, array[,,] row_vector) => array[,,] row_vector + lower_upper_bound_unconstrain(array[,,] row_vector, array[,,] row_vector, real) => array[,,] row_vector + lower_upper_bound_unconstrain(array[,,] row_vector, array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + lower_upper_bound_unconstrain(array[,,] matrix, real, array[,,] matrix) => array[,,] matrix + lower_upper_bound_unconstrain(array[,,] matrix, array[,,] matrix, real) => array[,,] matrix + lower_upper_bound_unconstrain(array[,,] matrix, array[,,] matrix, array[,,] matrix) => array[,,] matrix + lower_upper_bound_unconstrain(array[,,,] real, real, array[,,,] real) => array[,,,] real + lower_upper_bound_unconstrain(array[,,,] real, array[,,,] real, real) => array[,,,] real + lower_upper_bound_unconstrain(array[,,,] real, array[,,,] real, array[,,,] real) => array[,,,] real + lower_upper_bound_unconstrain(array[,,,] vector, real, array[,,,] vector) => array[,,,] vector + lower_upper_bound_unconstrain(array[,,,] vector, array[,,,] vector, real) => array[,,,] vector + lower_upper_bound_unconstrain(array[,,,] vector, array[,,,] vector, array[,,,] vector) => array[,,,] vector + lower_upper_bound_unconstrain(array[,,,] row_vector, real, array[,,,] row_vector) => array[,,,] row_vector + lower_upper_bound_unconstrain(array[,,,] row_vector, array[,,,] row_vector, real) => array[,,,] row_vector + lower_upper_bound_unconstrain(array[,,,] row_vector, array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + lower_upper_bound_unconstrain(array[,,,] matrix, real, array[,,,] matrix) => array[,,,] matrix + lower_upper_bound_unconstrain(array[,,,] matrix, array[,,,] matrix, real) => array[,,,] matrix + lower_upper_bound_unconstrain(array[,,,] matrix, array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + lower_upper_bound_unconstrain(array[,,,,] real, real, array[,,,,] real) => array[,,,,] real + lower_upper_bound_unconstrain(array[,,,,] real, array[,,,,] real, real) => array[,,,,] real + lower_upper_bound_unconstrain(array[,,,,] real, array[,,,,] real, array[,,,,] real) => array[,,,,] real + lower_upper_bound_unconstrain(array[,,,,] vector, real, array[,,,,] vector) => array[,,,,] vector + lower_upper_bound_unconstrain(array[,,,,] vector, array[,,,,] vector, real) => array[,,,,] vector + lower_upper_bound_unconstrain(array[,,,,] vector, array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + lower_upper_bound_unconstrain(array[,,,,] row_vector, real, array[,,,,] row_vector) => array[,,,,] row_vector + lower_upper_bound_unconstrain(array[,,,,] row_vector, array[,,,,] row_vector, real) => array[,,,,] row_vector + lower_upper_bound_unconstrain(array[,,,,] row_vector, array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + lower_upper_bound_unconstrain(array[,,,,] matrix, real, array[,,,,] matrix) => array[,,,,] matrix + lower_upper_bound_unconstrain(array[,,,,] matrix, array[,,,,] matrix, real) => array[,,,,] matrix + lower_upper_bound_unconstrain(array[,,,,] matrix, array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + lower_upper_bound_unconstrain(array[,,,,,] real, real, array[,,,,,] real) => array[,,,,,] real + lower_upper_bound_unconstrain(array[,,,,,] real, array[,,,,,] real, real) => array[,,,,,] real + lower_upper_bound_unconstrain(array[,,,,,] real, array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + lower_upper_bound_unconstrain(array[,,,,,] vector, real, array[,,,,,] vector) => array[,,,,,] vector + lower_upper_bound_unconstrain(array[,,,,,] vector, array[,,,,,] vector, real) => array[,,,,,] vector + lower_upper_bound_unconstrain(array[,,,,,] vector, array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + lower_upper_bound_unconstrain(array[,,,,,] row_vector, real, array[,,,,,] row_vector) => array[,,,,,] row_vector + lower_upper_bound_unconstrain(array[,,,,,] row_vector, array[,,,,,] row_vector, real) => array[,,,,,] row_vector + lower_upper_bound_unconstrain(array[,,,,,] row_vector, array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + lower_upper_bound_unconstrain(array[,,,,,] matrix, real, array[,,,,,] matrix) => array[,,,,,] matrix + lower_upper_bound_unconstrain(array[,,,,,] matrix, array[,,,,,] matrix, real) => array[,,,,,] matrix + lower_upper_bound_unconstrain(array[,,,,,] matrix, array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + lower_upper_bound_unconstrain(array[,,,,,,] real, real, array[,,,,,,] real) => array[,,,,,,] real + lower_upper_bound_unconstrain(array[,,,,,,] real, array[,,,,,,] real, real) => array[,,,,,,] real + lower_upper_bound_unconstrain(array[,,,,,,] real, array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + lower_upper_bound_unconstrain(array[,,,,,,] vector, real, array[,,,,,,] vector) => array[,,,,,,] vector + lower_upper_bound_unconstrain(array[,,,,,,] vector, array[,,,,,,] vector, real) => array[,,,,,,] vector + lower_upper_bound_unconstrain(array[,,,,,,] vector, array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + lower_upper_bound_unconstrain(array[,,,,,,] row_vector, real, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + lower_upper_bound_unconstrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + lower_upper_bound_unconstrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + lower_upper_bound_unconstrain(array[,,,,,,] matrix, real, array[,,,,,,] matrix) => array[,,,,,,] matrix + lower_upper_bound_unconstrain(array[,,,,,,] matrix, array[,,,,,,] matrix, real) => array[,,,,,,] matrix + lower_upper_bound_unconstrain(array[,,,,,,] matrix, array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + lower_upper_bound_unconstrain(array[,,,,,,,] real, real, array[,,,,,,,] real) => array[,,,,,,,] real + lower_upper_bound_unconstrain(array[,,,,,,,] real, array[,,,,,,,] real, real) => array[,,,,,,,] real + lower_upper_bound_unconstrain(array[,,,,,,,] real, array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real machine_precision() => real map_rect((vector, vector, data array[] real, data array[] int) => vector, vector, array[] vector, array[,] real, array[,] int) => vector matrix_exp(matrix) => matrix @@ -13220,6 +13802,297 @@ Display all Stan math signatures exposed in the language num_elements(array[,,,,,,,,] complex_vector) => int num_elements(array[,,,,,,,,] complex_row_vector) => int num_elements(array[,,,,,,,,] complex_matrix) => int + offset_multiplier_constrain(real, real, real) => real + offset_multiplier_constrain(vector, real, vector) => vector + offset_multiplier_constrain(vector, vector, real) => vector + offset_multiplier_constrain(vector, vector, vector) => vector + offset_multiplier_constrain(row_vector, real, row_vector) => row_vector + offset_multiplier_constrain(row_vector, row_vector, real) => row_vector + offset_multiplier_constrain(row_vector, row_vector, row_vector) => row_vector + offset_multiplier_constrain(matrix, real, matrix) => matrix + offset_multiplier_constrain(matrix, matrix, real) => matrix + offset_multiplier_constrain(matrix, matrix, matrix) => matrix + offset_multiplier_constrain(array[] real, real, array[] real) => array[] real + offset_multiplier_constrain(array[] real, array[] real, real) => array[] real + offset_multiplier_constrain(array[] real, array[] real, array[] real) => array[] real + offset_multiplier_constrain(array[] vector, real, array[] vector) => array[] vector + offset_multiplier_constrain(array[] vector, array[] vector, real) => array[] vector + offset_multiplier_constrain(array[] vector, array[] vector, array[] vector) => array[] vector + offset_multiplier_constrain(array[] row_vector, real, array[] row_vector) => array[] row_vector + offset_multiplier_constrain(array[] row_vector, array[] row_vector, real) => array[] row_vector + offset_multiplier_constrain(array[] row_vector, array[] row_vector, array[] row_vector) => array[] row_vector + offset_multiplier_constrain(array[] matrix, real, array[] matrix) => array[] matrix + offset_multiplier_constrain(array[] matrix, array[] matrix, real) => array[] matrix + offset_multiplier_constrain(array[] matrix, array[] matrix, array[] matrix) => array[] matrix + offset_multiplier_constrain(array[,] real, real, array[,] real) => array[,] real + offset_multiplier_constrain(array[,] real, array[,] real, real) => array[,] real + offset_multiplier_constrain(array[,] real, array[,] real, array[,] real) => array[,] real + offset_multiplier_constrain(array[,] vector, real, array[,] vector) => array[,] vector + offset_multiplier_constrain(array[,] vector, array[,] vector, real) => array[,] vector + offset_multiplier_constrain(array[,] vector, array[,] vector, array[,] vector) => array[,] vector + offset_multiplier_constrain(array[,] row_vector, real, array[,] row_vector) => array[,] row_vector + offset_multiplier_constrain(array[,] row_vector, array[,] row_vector, real) => array[,] row_vector + offset_multiplier_constrain(array[,] row_vector, array[,] row_vector, array[,] row_vector) => array[,] row_vector + offset_multiplier_constrain(array[,] matrix, real, array[,] matrix) => array[,] matrix + offset_multiplier_constrain(array[,] matrix, array[,] matrix, real) => array[,] matrix + offset_multiplier_constrain(array[,] matrix, array[,] matrix, array[,] matrix) => array[,] matrix + offset_multiplier_constrain(array[,,] real, real, array[,,] real) => array[,,] real + offset_multiplier_constrain(array[,,] real, array[,,] real, real) => array[,,] real + offset_multiplier_constrain(array[,,] real, array[,,] real, array[,,] real) => array[,,] real + offset_multiplier_constrain(array[,,] vector, real, array[,,] vector) => array[,,] vector + offset_multiplier_constrain(array[,,] vector, array[,,] vector, real) => array[,,] vector + offset_multiplier_constrain(array[,,] vector, array[,,] vector, array[,,] vector) => array[,,] vector + offset_multiplier_constrain(array[,,] row_vector, real, array[,,] row_vector) => array[,,] row_vector + offset_multiplier_constrain(array[,,] row_vector, array[,,] row_vector, real) => array[,,] row_vector + offset_multiplier_constrain(array[,,] row_vector, array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + offset_multiplier_constrain(array[,,] matrix, real, array[,,] matrix) => array[,,] matrix + offset_multiplier_constrain(array[,,] matrix, array[,,] matrix, real) => array[,,] matrix + offset_multiplier_constrain(array[,,] matrix, array[,,] matrix, array[,,] matrix) => array[,,] matrix + offset_multiplier_constrain(array[,,,] real, real, array[,,,] real) => array[,,,] real + offset_multiplier_constrain(array[,,,] real, array[,,,] real, real) => array[,,,] real + offset_multiplier_constrain(array[,,,] real, array[,,,] real, array[,,,] real) => array[,,,] real + offset_multiplier_constrain(array[,,,] vector, real, array[,,,] vector) => array[,,,] vector + offset_multiplier_constrain(array[,,,] vector, array[,,,] vector, real) => array[,,,] vector + offset_multiplier_constrain(array[,,,] vector, array[,,,] vector, array[,,,] vector) => array[,,,] vector + offset_multiplier_constrain(array[,,,] row_vector, real, array[,,,] row_vector) => array[,,,] row_vector + offset_multiplier_constrain(array[,,,] row_vector, array[,,,] row_vector, real) => array[,,,] row_vector + offset_multiplier_constrain(array[,,,] row_vector, array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + offset_multiplier_constrain(array[,,,] matrix, real, array[,,,] matrix) => array[,,,] matrix + offset_multiplier_constrain(array[,,,] matrix, array[,,,] matrix, real) => array[,,,] matrix + offset_multiplier_constrain(array[,,,] matrix, array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + offset_multiplier_constrain(array[,,,,] real, real, array[,,,,] real) => array[,,,,] real + offset_multiplier_constrain(array[,,,,] real, array[,,,,] real, real) => array[,,,,] real + offset_multiplier_constrain(array[,,,,] real, array[,,,,] real, array[,,,,] real) => array[,,,,] real + offset_multiplier_constrain(array[,,,,] vector, real, array[,,,,] vector) => array[,,,,] vector + offset_multiplier_constrain(array[,,,,] vector, array[,,,,] vector, real) => array[,,,,] vector + offset_multiplier_constrain(array[,,,,] vector, array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + offset_multiplier_constrain(array[,,,,] row_vector, real, array[,,,,] row_vector) => array[,,,,] row_vector + offset_multiplier_constrain(array[,,,,] row_vector, array[,,,,] row_vector, real) => array[,,,,] row_vector + offset_multiplier_constrain(array[,,,,] row_vector, array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + offset_multiplier_constrain(array[,,,,] matrix, real, array[,,,,] matrix) => array[,,,,] matrix + offset_multiplier_constrain(array[,,,,] matrix, array[,,,,] matrix, real) => array[,,,,] matrix + offset_multiplier_constrain(array[,,,,] matrix, array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + offset_multiplier_constrain(array[,,,,,] real, real, array[,,,,,] real) => array[,,,,,] real + offset_multiplier_constrain(array[,,,,,] real, array[,,,,,] real, real) => array[,,,,,] real + offset_multiplier_constrain(array[,,,,,] real, array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + offset_multiplier_constrain(array[,,,,,] vector, real, array[,,,,,] vector) => array[,,,,,] vector + offset_multiplier_constrain(array[,,,,,] vector, array[,,,,,] vector, real) => array[,,,,,] vector + offset_multiplier_constrain(array[,,,,,] vector, array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + offset_multiplier_constrain(array[,,,,,] row_vector, real, array[,,,,,] row_vector) => array[,,,,,] row_vector + offset_multiplier_constrain(array[,,,,,] row_vector, array[,,,,,] row_vector, real) => array[,,,,,] row_vector + offset_multiplier_constrain(array[,,,,,] row_vector, array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + offset_multiplier_constrain(array[,,,,,] matrix, real, array[,,,,,] matrix) => array[,,,,,] matrix + offset_multiplier_constrain(array[,,,,,] matrix, array[,,,,,] matrix, real) => array[,,,,,] matrix + offset_multiplier_constrain(array[,,,,,] matrix, array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + offset_multiplier_constrain(array[,,,,,,] real, real, array[,,,,,,] real) => array[,,,,,,] real + offset_multiplier_constrain(array[,,,,,,] real, array[,,,,,,] real, real) => array[,,,,,,] real + offset_multiplier_constrain(array[,,,,,,] real, array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + offset_multiplier_constrain(array[,,,,,,] vector, real, array[,,,,,,] vector) => array[,,,,,,] vector + offset_multiplier_constrain(array[,,,,,,] vector, array[,,,,,,] vector, real) => array[,,,,,,] vector + offset_multiplier_constrain(array[,,,,,,] vector, array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + offset_multiplier_constrain(array[,,,,,,] row_vector, real, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + offset_multiplier_constrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + offset_multiplier_constrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + offset_multiplier_constrain(array[,,,,,,] matrix, real, array[,,,,,,] matrix) => array[,,,,,,] matrix + offset_multiplier_constrain(array[,,,,,,] matrix, array[,,,,,,] matrix, real) => array[,,,,,,] matrix + offset_multiplier_constrain(array[,,,,,,] matrix, array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + offset_multiplier_constrain(array[,,,,,,,] real, real, array[,,,,,,,] real) => array[,,,,,,,] real + offset_multiplier_constrain(array[,,,,,,,] real, array[,,,,,,,] real, real) => array[,,,,,,,] real + offset_multiplier_constrain(array[,,,,,,,] real, array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real + offset_multiplier_jacobian(real, real, real) => real + offset_multiplier_jacobian(vector, real, vector) => vector + offset_multiplier_jacobian(vector, vector, real) => vector + offset_multiplier_jacobian(vector, vector, vector) => vector + offset_multiplier_jacobian(row_vector, real, row_vector) => row_vector + offset_multiplier_jacobian(row_vector, row_vector, real) => row_vector + offset_multiplier_jacobian(row_vector, row_vector, row_vector) => row_vector + offset_multiplier_jacobian(matrix, real, matrix) => matrix + offset_multiplier_jacobian(matrix, matrix, real) => matrix + offset_multiplier_jacobian(matrix, matrix, matrix) => matrix + offset_multiplier_jacobian(array[] real, real, array[] real) => array[] real + offset_multiplier_jacobian(array[] real, array[] real, real) => array[] real + offset_multiplier_jacobian(array[] real, array[] real, array[] real) => array[] real + offset_multiplier_jacobian(array[] vector, real, array[] vector) => array[] vector + offset_multiplier_jacobian(array[] vector, array[] vector, real) => array[] vector + offset_multiplier_jacobian(array[] vector, array[] vector, array[] vector) => array[] vector + offset_multiplier_jacobian(array[] row_vector, real, array[] row_vector) => array[] row_vector + offset_multiplier_jacobian(array[] row_vector, array[] row_vector, real) => array[] row_vector + offset_multiplier_jacobian(array[] row_vector, array[] row_vector, array[] row_vector) => array[] row_vector + offset_multiplier_jacobian(array[] matrix, real, array[] matrix) => array[] matrix + offset_multiplier_jacobian(array[] matrix, array[] matrix, real) => array[] matrix + offset_multiplier_jacobian(array[] matrix, array[] matrix, array[] matrix) => array[] matrix + offset_multiplier_jacobian(array[,] real, real, array[,] real) => array[,] real + offset_multiplier_jacobian(array[,] real, array[,] real, real) => array[,] real + offset_multiplier_jacobian(array[,] real, array[,] real, array[,] real) => array[,] real + offset_multiplier_jacobian(array[,] vector, real, array[,] vector) => array[,] vector + offset_multiplier_jacobian(array[,] vector, array[,] vector, real) => array[,] vector + offset_multiplier_jacobian(array[,] vector, array[,] vector, array[,] vector) => array[,] vector + offset_multiplier_jacobian(array[,] row_vector, real, array[,] row_vector) => array[,] row_vector + offset_multiplier_jacobian(array[,] row_vector, array[,] row_vector, real) => array[,] row_vector + offset_multiplier_jacobian(array[,] row_vector, array[,] row_vector, array[,] row_vector) => array[,] row_vector + offset_multiplier_jacobian(array[,] matrix, real, array[,] matrix) => array[,] matrix + offset_multiplier_jacobian(array[,] matrix, array[,] matrix, real) => array[,] matrix + offset_multiplier_jacobian(array[,] matrix, array[,] matrix, array[,] matrix) => array[,] matrix + offset_multiplier_jacobian(array[,,] real, real, array[,,] real) => array[,,] real + offset_multiplier_jacobian(array[,,] real, array[,,] real, real) => array[,,] real + offset_multiplier_jacobian(array[,,] real, array[,,] real, array[,,] real) => array[,,] real + offset_multiplier_jacobian(array[,,] vector, real, array[,,] vector) => array[,,] vector + offset_multiplier_jacobian(array[,,] vector, array[,,] vector, real) => array[,,] vector + offset_multiplier_jacobian(array[,,] vector, array[,,] vector, array[,,] vector) => array[,,] vector + offset_multiplier_jacobian(array[,,] row_vector, real, array[,,] row_vector) => array[,,] row_vector + offset_multiplier_jacobian(array[,,] row_vector, array[,,] row_vector, real) => array[,,] row_vector + offset_multiplier_jacobian(array[,,] row_vector, array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + offset_multiplier_jacobian(array[,,] matrix, real, array[,,] matrix) => array[,,] matrix + offset_multiplier_jacobian(array[,,] matrix, array[,,] matrix, real) => array[,,] matrix + offset_multiplier_jacobian(array[,,] matrix, array[,,] matrix, array[,,] matrix) => array[,,] matrix + offset_multiplier_jacobian(array[,,,] real, real, array[,,,] real) => array[,,,] real + offset_multiplier_jacobian(array[,,,] real, array[,,,] real, real) => array[,,,] real + offset_multiplier_jacobian(array[,,,] real, array[,,,] real, array[,,,] real) => array[,,,] real + offset_multiplier_jacobian(array[,,,] vector, real, array[,,,] vector) => array[,,,] vector + offset_multiplier_jacobian(array[,,,] vector, array[,,,] vector, real) => array[,,,] vector + offset_multiplier_jacobian(array[,,,] vector, array[,,,] vector, array[,,,] vector) => array[,,,] vector + offset_multiplier_jacobian(array[,,,] row_vector, real, array[,,,] row_vector) => array[,,,] row_vector + offset_multiplier_jacobian(array[,,,] row_vector, array[,,,] row_vector, real) => array[,,,] row_vector + offset_multiplier_jacobian(array[,,,] row_vector, array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + offset_multiplier_jacobian(array[,,,] matrix, real, array[,,,] matrix) => array[,,,] matrix + offset_multiplier_jacobian(array[,,,] matrix, array[,,,] matrix, real) => array[,,,] matrix + offset_multiplier_jacobian(array[,,,] matrix, array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + offset_multiplier_jacobian(array[,,,,] real, real, array[,,,,] real) => array[,,,,] real + offset_multiplier_jacobian(array[,,,,] real, array[,,,,] real, real) => array[,,,,] real + offset_multiplier_jacobian(array[,,,,] real, array[,,,,] real, array[,,,,] real) => array[,,,,] real + offset_multiplier_jacobian(array[,,,,] vector, real, array[,,,,] vector) => array[,,,,] vector + offset_multiplier_jacobian(array[,,,,] vector, array[,,,,] vector, real) => array[,,,,] vector + offset_multiplier_jacobian(array[,,,,] vector, array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + offset_multiplier_jacobian(array[,,,,] row_vector, real, array[,,,,] row_vector) => array[,,,,] row_vector + offset_multiplier_jacobian(array[,,,,] row_vector, array[,,,,] row_vector, real) => array[,,,,] row_vector + offset_multiplier_jacobian(array[,,,,] row_vector, array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + offset_multiplier_jacobian(array[,,,,] matrix, real, array[,,,,] matrix) => array[,,,,] matrix + offset_multiplier_jacobian(array[,,,,] matrix, array[,,,,] matrix, real) => array[,,,,] matrix + offset_multiplier_jacobian(array[,,,,] matrix, array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + offset_multiplier_jacobian(array[,,,,,] real, real, array[,,,,,] real) => array[,,,,,] real + offset_multiplier_jacobian(array[,,,,,] real, array[,,,,,] real, real) => array[,,,,,] real + offset_multiplier_jacobian(array[,,,,,] real, array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + offset_multiplier_jacobian(array[,,,,,] vector, real, array[,,,,,] vector) => array[,,,,,] vector + offset_multiplier_jacobian(array[,,,,,] vector, array[,,,,,] vector, real) => array[,,,,,] vector + offset_multiplier_jacobian(array[,,,,,] vector, array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + offset_multiplier_jacobian(array[,,,,,] row_vector, real, array[,,,,,] row_vector) => array[,,,,,] row_vector + offset_multiplier_jacobian(array[,,,,,] row_vector, array[,,,,,] row_vector, real) => array[,,,,,] row_vector + offset_multiplier_jacobian(array[,,,,,] row_vector, array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + offset_multiplier_jacobian(array[,,,,,] matrix, real, array[,,,,,] matrix) => array[,,,,,] matrix + offset_multiplier_jacobian(array[,,,,,] matrix, array[,,,,,] matrix, real) => array[,,,,,] matrix + offset_multiplier_jacobian(array[,,,,,] matrix, array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + offset_multiplier_jacobian(array[,,,,,,] real, real, array[,,,,,,] real) => array[,,,,,,] real + offset_multiplier_jacobian(array[,,,,,,] real, array[,,,,,,] real, real) => array[,,,,,,] real + offset_multiplier_jacobian(array[,,,,,,] real, array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + offset_multiplier_jacobian(array[,,,,,,] vector, real, array[,,,,,,] vector) => array[,,,,,,] vector + offset_multiplier_jacobian(array[,,,,,,] vector, array[,,,,,,] vector, real) => array[,,,,,,] vector + offset_multiplier_jacobian(array[,,,,,,] vector, array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + offset_multiplier_jacobian(array[,,,,,,] row_vector, real, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + offset_multiplier_jacobian(array[,,,,,,] row_vector, array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + offset_multiplier_jacobian(array[,,,,,,] row_vector, array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + offset_multiplier_jacobian(array[,,,,,,] matrix, real, array[,,,,,,] matrix) => array[,,,,,,] matrix + offset_multiplier_jacobian(array[,,,,,,] matrix, array[,,,,,,] matrix, real) => array[,,,,,,] matrix + offset_multiplier_jacobian(array[,,,,,,] matrix, array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + offset_multiplier_jacobian(array[,,,,,,,] real, real, array[,,,,,,,] real) => array[,,,,,,,] real + offset_multiplier_jacobian(array[,,,,,,,] real, array[,,,,,,,] real, real) => array[,,,,,,,] real + offset_multiplier_jacobian(array[,,,,,,,] real, array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real + offset_multiplier_unconstrain(real, real, real) => real + offset_multiplier_unconstrain(vector, real, vector) => vector + offset_multiplier_unconstrain(vector, vector, real) => vector + offset_multiplier_unconstrain(vector, vector, vector) => vector + offset_multiplier_unconstrain(row_vector, real, row_vector) => row_vector + offset_multiplier_unconstrain(row_vector, row_vector, real) => row_vector + offset_multiplier_unconstrain(row_vector, row_vector, row_vector) => row_vector + offset_multiplier_unconstrain(matrix, real, matrix) => matrix + offset_multiplier_unconstrain(matrix, matrix, real) => matrix + offset_multiplier_unconstrain(matrix, matrix, matrix) => matrix + offset_multiplier_unconstrain(array[] real, real, array[] real) => array[] real + offset_multiplier_unconstrain(array[] real, array[] real, real) => array[] real + offset_multiplier_unconstrain(array[] real, array[] real, array[] real) => array[] real + offset_multiplier_unconstrain(array[] vector, real, array[] vector) => array[] vector + offset_multiplier_unconstrain(array[] vector, array[] vector, real) => array[] vector + offset_multiplier_unconstrain(array[] vector, array[] vector, array[] vector) => array[] vector + offset_multiplier_unconstrain(array[] row_vector, real, array[] row_vector) => array[] row_vector + offset_multiplier_unconstrain(array[] row_vector, array[] row_vector, real) => array[] row_vector + offset_multiplier_unconstrain(array[] row_vector, array[] row_vector, array[] row_vector) => array[] row_vector + offset_multiplier_unconstrain(array[] matrix, real, array[] matrix) => array[] matrix + offset_multiplier_unconstrain(array[] matrix, array[] matrix, real) => array[] matrix + offset_multiplier_unconstrain(array[] matrix, array[] matrix, array[] matrix) => array[] matrix + offset_multiplier_unconstrain(array[,] real, real, array[,] real) => array[,] real + offset_multiplier_unconstrain(array[,] real, array[,] real, real) => array[,] real + offset_multiplier_unconstrain(array[,] real, array[,] real, array[,] real) => array[,] real + offset_multiplier_unconstrain(array[,] vector, real, array[,] vector) => array[,] vector + offset_multiplier_unconstrain(array[,] vector, array[,] vector, real) => array[,] vector + offset_multiplier_unconstrain(array[,] vector, array[,] vector, array[,] vector) => array[,] vector + offset_multiplier_unconstrain(array[,] row_vector, real, array[,] row_vector) => array[,] row_vector + offset_multiplier_unconstrain(array[,] row_vector, array[,] row_vector, real) => array[,] row_vector + offset_multiplier_unconstrain(array[,] row_vector, array[,] row_vector, array[,] row_vector) => array[,] row_vector + offset_multiplier_unconstrain(array[,] matrix, real, array[,] matrix) => array[,] matrix + offset_multiplier_unconstrain(array[,] matrix, array[,] matrix, real) => array[,] matrix + offset_multiplier_unconstrain(array[,] matrix, array[,] matrix, array[,] matrix) => array[,] matrix + offset_multiplier_unconstrain(array[,,] real, real, array[,,] real) => array[,,] real + offset_multiplier_unconstrain(array[,,] real, array[,,] real, real) => array[,,] real + offset_multiplier_unconstrain(array[,,] real, array[,,] real, array[,,] real) => array[,,] real + offset_multiplier_unconstrain(array[,,] vector, real, array[,,] vector) => array[,,] vector + offset_multiplier_unconstrain(array[,,] vector, array[,,] vector, real) => array[,,] vector + offset_multiplier_unconstrain(array[,,] vector, array[,,] vector, array[,,] vector) => array[,,] vector + offset_multiplier_unconstrain(array[,,] row_vector, real, array[,,] row_vector) => array[,,] row_vector + offset_multiplier_unconstrain(array[,,] row_vector, array[,,] row_vector, real) => array[,,] row_vector + offset_multiplier_unconstrain(array[,,] row_vector, array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + offset_multiplier_unconstrain(array[,,] matrix, real, array[,,] matrix) => array[,,] matrix + offset_multiplier_unconstrain(array[,,] matrix, array[,,] matrix, real) => array[,,] matrix + offset_multiplier_unconstrain(array[,,] matrix, array[,,] matrix, array[,,] matrix) => array[,,] matrix + offset_multiplier_unconstrain(array[,,,] real, real, array[,,,] real) => array[,,,] real + offset_multiplier_unconstrain(array[,,,] real, array[,,,] real, real) => array[,,,] real + offset_multiplier_unconstrain(array[,,,] real, array[,,,] real, array[,,,] real) => array[,,,] real + offset_multiplier_unconstrain(array[,,,] vector, real, array[,,,] vector) => array[,,,] vector + offset_multiplier_unconstrain(array[,,,] vector, array[,,,] vector, real) => array[,,,] vector + offset_multiplier_unconstrain(array[,,,] vector, array[,,,] vector, array[,,,] vector) => array[,,,] vector + offset_multiplier_unconstrain(array[,,,] row_vector, real, array[,,,] row_vector) => array[,,,] row_vector + offset_multiplier_unconstrain(array[,,,] row_vector, array[,,,] row_vector, real) => array[,,,] row_vector + offset_multiplier_unconstrain(array[,,,] row_vector, array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + offset_multiplier_unconstrain(array[,,,] matrix, real, array[,,,] matrix) => array[,,,] matrix + offset_multiplier_unconstrain(array[,,,] matrix, array[,,,] matrix, real) => array[,,,] matrix + offset_multiplier_unconstrain(array[,,,] matrix, array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + offset_multiplier_unconstrain(array[,,,,] real, real, array[,,,,] real) => array[,,,,] real + offset_multiplier_unconstrain(array[,,,,] real, array[,,,,] real, real) => array[,,,,] real + offset_multiplier_unconstrain(array[,,,,] real, array[,,,,] real, array[,,,,] real) => array[,,,,] real + offset_multiplier_unconstrain(array[,,,,] vector, real, array[,,,,] vector) => array[,,,,] vector + offset_multiplier_unconstrain(array[,,,,] vector, array[,,,,] vector, real) => array[,,,,] vector + offset_multiplier_unconstrain(array[,,,,] vector, array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + offset_multiplier_unconstrain(array[,,,,] row_vector, real, array[,,,,] row_vector) => array[,,,,] row_vector + offset_multiplier_unconstrain(array[,,,,] row_vector, array[,,,,] row_vector, real) => array[,,,,] row_vector + offset_multiplier_unconstrain(array[,,,,] row_vector, array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + offset_multiplier_unconstrain(array[,,,,] matrix, real, array[,,,,] matrix) => array[,,,,] matrix + offset_multiplier_unconstrain(array[,,,,] matrix, array[,,,,] matrix, real) => array[,,,,] matrix + offset_multiplier_unconstrain(array[,,,,] matrix, array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + offset_multiplier_unconstrain(array[,,,,,] real, real, array[,,,,,] real) => array[,,,,,] real + offset_multiplier_unconstrain(array[,,,,,] real, array[,,,,,] real, real) => array[,,,,,] real + offset_multiplier_unconstrain(array[,,,,,] real, array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + offset_multiplier_unconstrain(array[,,,,,] vector, real, array[,,,,,] vector) => array[,,,,,] vector + offset_multiplier_unconstrain(array[,,,,,] vector, array[,,,,,] vector, real) => array[,,,,,] vector + offset_multiplier_unconstrain(array[,,,,,] vector, array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + offset_multiplier_unconstrain(array[,,,,,] row_vector, real, array[,,,,,] row_vector) => array[,,,,,] row_vector + offset_multiplier_unconstrain(array[,,,,,] row_vector, array[,,,,,] row_vector, real) => array[,,,,,] row_vector + offset_multiplier_unconstrain(array[,,,,,] row_vector, array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + offset_multiplier_unconstrain(array[,,,,,] matrix, real, array[,,,,,] matrix) => array[,,,,,] matrix + offset_multiplier_unconstrain(array[,,,,,] matrix, array[,,,,,] matrix, real) => array[,,,,,] matrix + offset_multiplier_unconstrain(array[,,,,,] matrix, array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + offset_multiplier_unconstrain(array[,,,,,,] real, real, array[,,,,,,] real) => array[,,,,,,] real + offset_multiplier_unconstrain(array[,,,,,,] real, array[,,,,,,] real, real) => array[,,,,,,] real + offset_multiplier_unconstrain(array[,,,,,,] real, array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + offset_multiplier_unconstrain(array[,,,,,,] vector, real, array[,,,,,,] vector) => array[,,,,,,] vector + offset_multiplier_unconstrain(array[,,,,,,] vector, array[,,,,,,] vector, real) => array[,,,,,,] vector + offset_multiplier_unconstrain(array[,,,,,,] vector, array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + offset_multiplier_unconstrain(array[,,,,,,] row_vector, real, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + offset_multiplier_unconstrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + offset_multiplier_unconstrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + offset_multiplier_unconstrain(array[,,,,,,] matrix, real, array[,,,,,,] matrix) => array[,,,,,,] matrix + offset_multiplier_unconstrain(array[,,,,,,] matrix, array[,,,,,,] matrix, real) => array[,,,,,,] matrix + offset_multiplier_unconstrain(array[,,,,,,] matrix, array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + offset_multiplier_unconstrain(array[,,,,,,,] real, real, array[,,,,,,,] real) => array[,,,,,,,] real + offset_multiplier_unconstrain(array[,,,,,,,] real, array[,,,,,,,] real, real) => array[,,,,,,,] real + offset_multiplier_unconstrain(array[,,,,,,,] real, array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real one_hot_array(int, int) => array[] real one_hot_int_array(int, int) => array[] int one_hot_row_vector(int, int) => row_vector @@ -13228,6 +14101,22 @@ Display all Stan math signatures exposed in the language ones_int_array(int) => array[] int ones_row_vector(int) => row_vector ones_vector(int) => vector + ordered_constrain(vector) => vector + ordered_constrain(array[] vector) => array[] vector + ordered_constrain(array[,] vector) => array[,] vector + ordered_constrain(array[,,] vector) => array[,,] vector + ordered_constrain(array[,,,] vector) => array[,,,] vector + ordered_constrain(array[,,,,] vector) => array[,,,,] vector + ordered_constrain(array[,,,,,] vector) => array[,,,,,] vector + ordered_constrain(array[,,,,,,] vector) => array[,,,,,,] vector + ordered_jacobian(vector) => vector + ordered_jacobian(array[] vector) => array[] vector + ordered_jacobian(array[,] vector) => array[,] vector + ordered_jacobian(array[,,] vector) => array[,,] vector + ordered_jacobian(array[,,,] vector) => array[,,,] vector + ordered_jacobian(array[,,,,] vector) => array[,,,,] vector + ordered_jacobian(array[,,,,,] vector) => array[,,,,,] vector + ordered_jacobian(array[,,,,,,] vector) => array[,,,,,,] vector ordered_logistic_glm_lpmf(int, row_vector, vector, vector) => real ordered_logistic_glm_lpmf(int, matrix, vector, vector) => real ordered_logistic_glm_lpmf(array[] int, row_vector, vector, vector) => real @@ -13242,6 +14131,14 @@ Display all Stan math signatures exposed in the language ordered_probit_lpmf(array[] int, vector, vector) => real ordered_probit_lpmf(array[] int, vector, array[] vector) => real ordered_probit_rng(real, vector) => int + ordered_unconstrain(vector) => vector + ordered_unconstrain(array[] vector) => array[] vector + ordered_unconstrain(array[,] vector) => array[,] vector + ordered_unconstrain(array[,,] vector) => array[,,] vector + ordered_unconstrain(array[,,,] vector) => array[,,,] vector + ordered_unconstrain(array[,,,,] vector) => array[,,,,] vector + ordered_unconstrain(array[,,,,,] vector) => array[,,,,,] vector + ordered_unconstrain(array[,,,,,,] vector) => array[,,,,,,] vector owens_t(real, real) => real owens_t(real, vector) => vector owens_t(real, row_vector) => row_vector @@ -14938,6 +15835,30 @@ Display all Stan math signatures exposed in the language poisson_rng(array[] real) => array[] int polar(real, real) => complex positive_infinity() => real + positive_ordered_constrain(vector) => vector + positive_ordered_constrain(array[] vector) => array[] vector + positive_ordered_constrain(array[,] vector) => array[,] vector + positive_ordered_constrain(array[,,] vector) => array[,,] vector + positive_ordered_constrain(array[,,,] vector) => array[,,,] vector + positive_ordered_constrain(array[,,,,] vector) => array[,,,,] vector + positive_ordered_constrain(array[,,,,,] vector) => array[,,,,,] vector + positive_ordered_constrain(array[,,,,,,] vector) => array[,,,,,,] vector + positive_ordered_jacobian(vector) => vector + positive_ordered_jacobian(array[] vector) => array[] vector + positive_ordered_jacobian(array[,] vector) => array[,] vector + positive_ordered_jacobian(array[,,] vector) => array[,,] vector + positive_ordered_jacobian(array[,,,] vector) => array[,,,] vector + positive_ordered_jacobian(array[,,,,] vector) => array[,,,,] vector + positive_ordered_jacobian(array[,,,,,] vector) => array[,,,,,] vector + positive_ordered_jacobian(array[,,,,,,] vector) => array[,,,,,,] vector + positive_ordered_unconstrain(vector) => vector + positive_ordered_unconstrain(array[] vector) => array[] vector + positive_ordered_unconstrain(array[,] vector) => array[,] vector + positive_ordered_unconstrain(array[,,] vector) => array[,,] vector + positive_ordered_unconstrain(array[,,,] vector) => array[,,,] vector + positive_ordered_unconstrain(array[,,,,] vector) => array[,,,,] vector + positive_ordered_unconstrain(array[,,,,,] vector) => array[,,,,,] vector + positive_ordered_unconstrain(array[,,,,,,] vector) => array[,,,,,,] vector pow(int, int) => real pow(int, real) => real pow(int, vector) => vector @@ -15981,6 +16902,30 @@ Display all Stan math signatures exposed in the language segment(array[,,] complex_vector, int, int) => array[,,] complex_vector segment(array[,,] complex_row_vector, int, int) => array[,,] complex_row_vector segment(array[,,] complex_matrix, int, int) => array[,,] complex_matrix + simplex_constrain(vector) => vector + simplex_constrain(array[] vector) => array[] vector + simplex_constrain(array[,] vector) => array[,] vector + simplex_constrain(array[,,] vector) => array[,,] vector + simplex_constrain(array[,,,] vector) => array[,,,] vector + simplex_constrain(array[,,,,] vector) => array[,,,,] vector + simplex_constrain(array[,,,,,] vector) => array[,,,,,] vector + simplex_constrain(array[,,,,,,] vector) => array[,,,,,,] vector + simplex_jacobian(vector) => vector + simplex_jacobian(array[] vector) => array[] vector + simplex_jacobian(array[,] vector) => array[,] vector + simplex_jacobian(array[,,] vector) => array[,,] vector + simplex_jacobian(array[,,,] vector) => array[,,,] vector + simplex_jacobian(array[,,,,] vector) => array[,,,,] vector + simplex_jacobian(array[,,,,,] vector) => array[,,,,,] vector + simplex_jacobian(array[,,,,,,] vector) => array[,,,,,,] vector + simplex_unconstrain(vector) => vector + simplex_unconstrain(array[] vector) => array[] vector + simplex_unconstrain(array[,] vector) => array[,] vector + simplex_unconstrain(array[,,] vector) => array[,,] vector + simplex_unconstrain(array[,,,] vector) => array[,,,] vector + simplex_unconstrain(array[,,,,] vector) => array[,,,,] vector + simplex_unconstrain(array[,,,,,] vector) => array[,,,,,] vector + simplex_unconstrain(array[,,,,,,] vector) => array[,,,,,,] vector sin(int) => real sin(real) => real sin(vector) => vector @@ -18819,6 +19764,54 @@ Display all Stan math signatures exposed in the language std_normal_qf(array[,,,,,,] matrix) => array[,,,,,,] matrix std_normal_rng() => real step(real) => real + stochastic_column_constrain(matrix) => matrix + stochastic_column_constrain(array[] matrix) => array[] matrix + stochastic_column_constrain(array[,] matrix) => array[,] matrix + stochastic_column_constrain(array[,,] matrix) => array[,,] matrix + stochastic_column_constrain(array[,,,] matrix) => array[,,,] matrix + stochastic_column_constrain(array[,,,,] matrix) => array[,,,,] matrix + stochastic_column_constrain(array[,,,,,] matrix) => array[,,,,,] matrix + stochastic_column_constrain(array[,,,,,,] matrix) => array[,,,,,,] matrix + stochastic_column_jacobian(matrix) => matrix + stochastic_column_jacobian(array[] matrix) => array[] matrix + stochastic_column_jacobian(array[,] matrix) => array[,] matrix + stochastic_column_jacobian(array[,,] matrix) => array[,,] matrix + stochastic_column_jacobian(array[,,,] matrix) => array[,,,] matrix + stochastic_column_jacobian(array[,,,,] matrix) => array[,,,,] matrix + stochastic_column_jacobian(array[,,,,,] matrix) => array[,,,,,] matrix + stochastic_column_jacobian(array[,,,,,,] matrix) => array[,,,,,,] matrix + stochastic_column_unconstrain(matrix) => matrix + stochastic_column_unconstrain(array[] matrix) => array[] matrix + stochastic_column_unconstrain(array[,] matrix) => array[,] matrix + stochastic_column_unconstrain(array[,,] matrix) => array[,,] matrix + stochastic_column_unconstrain(array[,,,] matrix) => array[,,,] matrix + stochastic_column_unconstrain(array[,,,,] matrix) => array[,,,,] matrix + stochastic_column_unconstrain(array[,,,,,] matrix) => array[,,,,,] matrix + stochastic_column_unconstrain(array[,,,,,,] matrix) => array[,,,,,,] matrix + stochastic_row_constrain(matrix) => matrix + stochastic_row_constrain(array[] matrix) => array[] matrix + stochastic_row_constrain(array[,] matrix) => array[,] matrix + stochastic_row_constrain(array[,,] matrix) => array[,,] matrix + stochastic_row_constrain(array[,,,] matrix) => array[,,,] matrix + stochastic_row_constrain(array[,,,,] matrix) => array[,,,,] matrix + stochastic_row_constrain(array[,,,,,] matrix) => array[,,,,,] matrix + stochastic_row_constrain(array[,,,,,,] matrix) => array[,,,,,,] matrix + stochastic_row_jacobian(matrix) => matrix + stochastic_row_jacobian(array[] matrix) => array[] matrix + stochastic_row_jacobian(array[,] matrix) => array[,] matrix + stochastic_row_jacobian(array[,,] matrix) => array[,,] matrix + stochastic_row_jacobian(array[,,,] matrix) => array[,,,] matrix + stochastic_row_jacobian(array[,,,,] matrix) => array[,,,,] matrix + stochastic_row_jacobian(array[,,,,,] matrix) => array[,,,,,] matrix + stochastic_row_jacobian(array[,,,,,,] matrix) => array[,,,,,,] matrix + stochastic_row_unconstrain(matrix) => matrix + stochastic_row_unconstrain(array[] matrix) => array[] matrix + stochastic_row_unconstrain(array[,] matrix) => array[,] matrix + stochastic_row_unconstrain(array[,,] matrix) => array[,,] matrix + stochastic_row_unconstrain(array[,,,] matrix) => array[,,,] matrix + stochastic_row_unconstrain(array[,,,,] matrix) => array[,,,,] matrix + stochastic_row_unconstrain(array[,,,,,] matrix) => array[,,,,,] matrix + stochastic_row_unconstrain(array[,,,,,,] matrix) => array[,,,,,,] matrix student_t_cdf(real, real, real, real) => real student_t_cdf(real, real, real, vector) => real student_t_cdf(real, real, real, row_vector) => real @@ -20093,6 +21086,30 @@ Display all Stan math signatures exposed in the language sum(array[] int) => int sum(array[] real) => real sum(array[] complex) => complex + sum_to_zero_constrain(vector) => vector + sum_to_zero_constrain(array[] vector) => array[] vector + sum_to_zero_constrain(array[,] vector) => array[,] vector + sum_to_zero_constrain(array[,,] vector) => array[,,] vector + sum_to_zero_constrain(array[,,,] vector) => array[,,,] vector + sum_to_zero_constrain(array[,,,,] vector) => array[,,,,] vector + sum_to_zero_constrain(array[,,,,,] vector) => array[,,,,,] vector + sum_to_zero_constrain(array[,,,,,,] vector) => array[,,,,,,] vector + sum_to_zero_jacobian(vector) => vector + sum_to_zero_jacobian(array[] vector) => array[] vector + sum_to_zero_jacobian(array[,] vector) => array[,] vector + sum_to_zero_jacobian(array[,,] vector) => array[,,] vector + sum_to_zero_jacobian(array[,,,] vector) => array[,,,] vector + sum_to_zero_jacobian(array[,,,,] vector) => array[,,,,] vector + sum_to_zero_jacobian(array[,,,,,] vector) => array[,,,,,] vector + sum_to_zero_jacobian(array[,,,,,,] vector) => array[,,,,,,] vector + sum_to_zero_unconstrain(vector) => vector + sum_to_zero_unconstrain(array[] vector) => array[] vector + sum_to_zero_unconstrain(array[,] vector) => array[,] vector + sum_to_zero_unconstrain(array[,,] vector) => array[,,] vector + sum_to_zero_unconstrain(array[,,,] vector) => array[,,,] vector + sum_to_zero_unconstrain(array[,,,,] vector) => array[,,,,] vector + sum_to_zero_unconstrain(array[,,,,,] vector) => array[,,,,,] vector + sum_to_zero_unconstrain(array[,,,,,,] vector) => array[,,,,,,] vector svd(matrix) => tuple(matrix, vector, matrix) svd(complex_matrix) => tuple(complex_matrix, vector, complex_matrix) svd_U(matrix) => matrix @@ -20827,6 +21844,225 @@ Display all Stan math signatures exposed in the language uniform_rng(array[] real, array[] int) => array[] real uniform_rng(array[] real, array[] real) => array[] real uniform_simplex(int) => vector + unit_vector_constrain(vector) => vector + unit_vector_constrain(array[] vector) => array[] vector + unit_vector_constrain(array[,] vector) => array[,] vector + unit_vector_constrain(array[,,] vector) => array[,,] vector + unit_vector_constrain(array[,,,] vector) => array[,,,] vector + unit_vector_constrain(array[,,,,] vector) => array[,,,,] vector + unit_vector_constrain(array[,,,,,] vector) => array[,,,,,] vector + unit_vector_constrain(array[,,,,,,] vector) => array[,,,,,,] vector + unit_vector_jacobian(vector) => vector + unit_vector_jacobian(array[] vector) => array[] vector + unit_vector_jacobian(array[,] vector) => array[,] vector + unit_vector_jacobian(array[,,] vector) => array[,,] vector + unit_vector_jacobian(array[,,,] vector) => array[,,,] vector + unit_vector_jacobian(array[,,,,] vector) => array[,,,,] vector + unit_vector_jacobian(array[,,,,,] vector) => array[,,,,,] vector + unit_vector_jacobian(array[,,,,,,] vector) => array[,,,,,,] vector + unit_vector_unconstrain(vector) => vector + unit_vector_unconstrain(array[] vector) => array[] vector + unit_vector_unconstrain(array[,] vector) => array[,] vector + unit_vector_unconstrain(array[,,] vector) => array[,,] vector + unit_vector_unconstrain(array[,,,] vector) => array[,,,] vector + unit_vector_unconstrain(array[,,,,] vector) => array[,,,,] vector + unit_vector_unconstrain(array[,,,,,] vector) => array[,,,,,] vector + unit_vector_unconstrain(array[,,,,,,] vector) => array[,,,,,,] vector + upper_bound_constrain(real, real) => real + upper_bound_constrain(vector, real) => vector + upper_bound_constrain(vector, vector) => vector + upper_bound_constrain(row_vector, real) => row_vector + upper_bound_constrain(row_vector, row_vector) => row_vector + upper_bound_constrain(matrix, real) => matrix + upper_bound_constrain(matrix, matrix) => matrix + upper_bound_constrain(array[] real, real) => array[] real + upper_bound_constrain(array[] real, array[] real) => array[] real + upper_bound_constrain(array[] vector, real) => array[] vector + upper_bound_constrain(array[] vector, array[] vector) => array[] vector + upper_bound_constrain(array[] row_vector, real) => array[] row_vector + upper_bound_constrain(array[] row_vector, array[] row_vector) => array[] row_vector + upper_bound_constrain(array[] matrix, real) => array[] matrix + upper_bound_constrain(array[] matrix, array[] matrix) => array[] matrix + upper_bound_constrain(array[,] real, real) => array[,] real + upper_bound_constrain(array[,] real, array[,] real) => array[,] real + upper_bound_constrain(array[,] vector, real) => array[,] vector + upper_bound_constrain(array[,] vector, array[,] vector) => array[,] vector + upper_bound_constrain(array[,] row_vector, real) => array[,] row_vector + upper_bound_constrain(array[,] row_vector, array[,] row_vector) => array[,] row_vector + upper_bound_constrain(array[,] matrix, real) => array[,] matrix + upper_bound_constrain(array[,] matrix, array[,] matrix) => array[,] matrix + upper_bound_constrain(array[,,] real, real) => array[,,] real + upper_bound_constrain(array[,,] real, array[,,] real) => array[,,] real + upper_bound_constrain(array[,,] vector, real) => array[,,] vector + upper_bound_constrain(array[,,] vector, array[,,] vector) => array[,,] vector + upper_bound_constrain(array[,,] row_vector, real) => array[,,] row_vector + upper_bound_constrain(array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + upper_bound_constrain(array[,,] matrix, real) => array[,,] matrix + upper_bound_constrain(array[,,] matrix, array[,,] matrix) => array[,,] matrix + upper_bound_constrain(array[,,,] real, real) => array[,,,] real + upper_bound_constrain(array[,,,] real, array[,,,] real) => array[,,,] real + upper_bound_constrain(array[,,,] vector, real) => array[,,,] vector + upper_bound_constrain(array[,,,] vector, array[,,,] vector) => array[,,,] vector + upper_bound_constrain(array[,,,] row_vector, real) => array[,,,] row_vector + upper_bound_constrain(array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + upper_bound_constrain(array[,,,] matrix, real) => array[,,,] matrix + upper_bound_constrain(array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + upper_bound_constrain(array[,,,,] real, real) => array[,,,,] real + upper_bound_constrain(array[,,,,] real, array[,,,,] real) => array[,,,,] real + upper_bound_constrain(array[,,,,] vector, real) => array[,,,,] vector + upper_bound_constrain(array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + upper_bound_constrain(array[,,,,] row_vector, real) => array[,,,,] row_vector + upper_bound_constrain(array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + upper_bound_constrain(array[,,,,] matrix, real) => array[,,,,] matrix + upper_bound_constrain(array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + upper_bound_constrain(array[,,,,,] real, real) => array[,,,,,] real + upper_bound_constrain(array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + upper_bound_constrain(array[,,,,,] vector, real) => array[,,,,,] vector + upper_bound_constrain(array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + upper_bound_constrain(array[,,,,,] row_vector, real) => array[,,,,,] row_vector + upper_bound_constrain(array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + upper_bound_constrain(array[,,,,,] matrix, real) => array[,,,,,] matrix + upper_bound_constrain(array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + upper_bound_constrain(array[,,,,,,] real, real) => array[,,,,,,] real + upper_bound_constrain(array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + upper_bound_constrain(array[,,,,,,] vector, real) => array[,,,,,,] vector + upper_bound_constrain(array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + upper_bound_constrain(array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + upper_bound_constrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + upper_bound_constrain(array[,,,,,,] matrix, real) => array[,,,,,,] matrix + upper_bound_constrain(array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + upper_bound_constrain(array[,,,,,,,] real, real) => array[,,,,,,,] real + upper_bound_constrain(array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real + upper_bound_jacobian(real, real) => real + upper_bound_jacobian(vector, real) => vector + upper_bound_jacobian(vector, vector) => vector + upper_bound_jacobian(row_vector, real) => row_vector + upper_bound_jacobian(row_vector, row_vector) => row_vector + upper_bound_jacobian(matrix, real) => matrix + upper_bound_jacobian(matrix, matrix) => matrix + upper_bound_jacobian(array[] real, real) => array[] real + upper_bound_jacobian(array[] real, array[] real) => array[] real + upper_bound_jacobian(array[] vector, real) => array[] vector + upper_bound_jacobian(array[] vector, array[] vector) => array[] vector + upper_bound_jacobian(array[] row_vector, real) => array[] row_vector + upper_bound_jacobian(array[] row_vector, array[] row_vector) => array[] row_vector + upper_bound_jacobian(array[] matrix, real) => array[] matrix + upper_bound_jacobian(array[] matrix, array[] matrix) => array[] matrix + upper_bound_jacobian(array[,] real, real) => array[,] real + upper_bound_jacobian(array[,] real, array[,] real) => array[,] real + upper_bound_jacobian(array[,] vector, real) => array[,] vector + upper_bound_jacobian(array[,] vector, array[,] vector) => array[,] vector + upper_bound_jacobian(array[,] row_vector, real) => array[,] row_vector + upper_bound_jacobian(array[,] row_vector, array[,] row_vector) => array[,] row_vector + upper_bound_jacobian(array[,] matrix, real) => array[,] matrix + upper_bound_jacobian(array[,] matrix, array[,] matrix) => array[,] matrix + upper_bound_jacobian(array[,,] real, real) => array[,,] real + upper_bound_jacobian(array[,,] real, array[,,] real) => array[,,] real + upper_bound_jacobian(array[,,] vector, real) => array[,,] vector + upper_bound_jacobian(array[,,] vector, array[,,] vector) => array[,,] vector + upper_bound_jacobian(array[,,] row_vector, real) => array[,,] row_vector + upper_bound_jacobian(array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + upper_bound_jacobian(array[,,] matrix, real) => array[,,] matrix + upper_bound_jacobian(array[,,] matrix, array[,,] matrix) => array[,,] matrix + upper_bound_jacobian(array[,,,] real, real) => array[,,,] real + upper_bound_jacobian(array[,,,] real, array[,,,] real) => array[,,,] real + upper_bound_jacobian(array[,,,] vector, real) => array[,,,] vector + upper_bound_jacobian(array[,,,] vector, array[,,,] vector) => array[,,,] vector + upper_bound_jacobian(array[,,,] row_vector, real) => array[,,,] row_vector + upper_bound_jacobian(array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + upper_bound_jacobian(array[,,,] matrix, real) => array[,,,] matrix + upper_bound_jacobian(array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + upper_bound_jacobian(array[,,,,] real, real) => array[,,,,] real + upper_bound_jacobian(array[,,,,] real, array[,,,,] real) => array[,,,,] real + upper_bound_jacobian(array[,,,,] vector, real) => array[,,,,] vector + upper_bound_jacobian(array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + upper_bound_jacobian(array[,,,,] row_vector, real) => array[,,,,] row_vector + upper_bound_jacobian(array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + upper_bound_jacobian(array[,,,,] matrix, real) => array[,,,,] matrix + upper_bound_jacobian(array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + upper_bound_jacobian(array[,,,,,] real, real) => array[,,,,,] real + upper_bound_jacobian(array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + upper_bound_jacobian(array[,,,,,] vector, real) => array[,,,,,] vector + upper_bound_jacobian(array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + upper_bound_jacobian(array[,,,,,] row_vector, real) => array[,,,,,] row_vector + upper_bound_jacobian(array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + upper_bound_jacobian(array[,,,,,] matrix, real) => array[,,,,,] matrix + upper_bound_jacobian(array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + upper_bound_jacobian(array[,,,,,,] real, real) => array[,,,,,,] real + upper_bound_jacobian(array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + upper_bound_jacobian(array[,,,,,,] vector, real) => array[,,,,,,] vector + upper_bound_jacobian(array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + upper_bound_jacobian(array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + upper_bound_jacobian(array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + upper_bound_jacobian(array[,,,,,,] matrix, real) => array[,,,,,,] matrix + upper_bound_jacobian(array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + upper_bound_jacobian(array[,,,,,,,] real, real) => array[,,,,,,,] real + upper_bound_jacobian(array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real + upper_bound_unconstrain(real, real) => real + upper_bound_unconstrain(vector, real) => vector + upper_bound_unconstrain(vector, vector) => vector + upper_bound_unconstrain(row_vector, real) => row_vector + upper_bound_unconstrain(row_vector, row_vector) => row_vector + upper_bound_unconstrain(matrix, real) => matrix + upper_bound_unconstrain(matrix, matrix) => matrix + upper_bound_unconstrain(array[] real, real) => array[] real + upper_bound_unconstrain(array[] real, array[] real) => array[] real + upper_bound_unconstrain(array[] vector, real) => array[] vector + upper_bound_unconstrain(array[] vector, array[] vector) => array[] vector + upper_bound_unconstrain(array[] row_vector, real) => array[] row_vector + upper_bound_unconstrain(array[] row_vector, array[] row_vector) => array[] row_vector + upper_bound_unconstrain(array[] matrix, real) => array[] matrix + upper_bound_unconstrain(array[] matrix, array[] matrix) => array[] matrix + upper_bound_unconstrain(array[,] real, real) => array[,] real + upper_bound_unconstrain(array[,] real, array[,] real) => array[,] real + upper_bound_unconstrain(array[,] vector, real) => array[,] vector + upper_bound_unconstrain(array[,] vector, array[,] vector) => array[,] vector + upper_bound_unconstrain(array[,] row_vector, real) => array[,] row_vector + upper_bound_unconstrain(array[,] row_vector, array[,] row_vector) => array[,] row_vector + upper_bound_unconstrain(array[,] matrix, real) => array[,] matrix + upper_bound_unconstrain(array[,] matrix, array[,] matrix) => array[,] matrix + upper_bound_unconstrain(array[,,] real, real) => array[,,] real + upper_bound_unconstrain(array[,,] real, array[,,] real) => array[,,] real + upper_bound_unconstrain(array[,,] vector, real) => array[,,] vector + upper_bound_unconstrain(array[,,] vector, array[,,] vector) => array[,,] vector + upper_bound_unconstrain(array[,,] row_vector, real) => array[,,] row_vector + upper_bound_unconstrain(array[,,] row_vector, array[,,] row_vector) => array[,,] row_vector + upper_bound_unconstrain(array[,,] matrix, real) => array[,,] matrix + upper_bound_unconstrain(array[,,] matrix, array[,,] matrix) => array[,,] matrix + upper_bound_unconstrain(array[,,,] real, real) => array[,,,] real + upper_bound_unconstrain(array[,,,] real, array[,,,] real) => array[,,,] real + upper_bound_unconstrain(array[,,,] vector, real) => array[,,,] vector + upper_bound_unconstrain(array[,,,] vector, array[,,,] vector) => array[,,,] vector + upper_bound_unconstrain(array[,,,] row_vector, real) => array[,,,] row_vector + upper_bound_unconstrain(array[,,,] row_vector, array[,,,] row_vector) => array[,,,] row_vector + upper_bound_unconstrain(array[,,,] matrix, real) => array[,,,] matrix + upper_bound_unconstrain(array[,,,] matrix, array[,,,] matrix) => array[,,,] matrix + upper_bound_unconstrain(array[,,,,] real, real) => array[,,,,] real + upper_bound_unconstrain(array[,,,,] real, array[,,,,] real) => array[,,,,] real + upper_bound_unconstrain(array[,,,,] vector, real) => array[,,,,] vector + upper_bound_unconstrain(array[,,,,] vector, array[,,,,] vector) => array[,,,,] vector + upper_bound_unconstrain(array[,,,,] row_vector, real) => array[,,,,] row_vector + upper_bound_unconstrain(array[,,,,] row_vector, array[,,,,] row_vector) => array[,,,,] row_vector + upper_bound_unconstrain(array[,,,,] matrix, real) => array[,,,,] matrix + upper_bound_unconstrain(array[,,,,] matrix, array[,,,,] matrix) => array[,,,,] matrix + upper_bound_unconstrain(array[,,,,,] real, real) => array[,,,,,] real + upper_bound_unconstrain(array[,,,,,] real, array[,,,,,] real) => array[,,,,,] real + upper_bound_unconstrain(array[,,,,,] vector, real) => array[,,,,,] vector + upper_bound_unconstrain(array[,,,,,] vector, array[,,,,,] vector) => array[,,,,,] vector + upper_bound_unconstrain(array[,,,,,] row_vector, real) => array[,,,,,] row_vector + upper_bound_unconstrain(array[,,,,,] row_vector, array[,,,,,] row_vector) => array[,,,,,] row_vector + upper_bound_unconstrain(array[,,,,,] matrix, real) => array[,,,,,] matrix + upper_bound_unconstrain(array[,,,,,] matrix, array[,,,,,] matrix) => array[,,,,,] matrix + upper_bound_unconstrain(array[,,,,,,] real, real) => array[,,,,,,] real + upper_bound_unconstrain(array[,,,,,,] real, array[,,,,,,] real) => array[,,,,,,] real + upper_bound_unconstrain(array[,,,,,,] vector, real) => array[,,,,,,] vector + upper_bound_unconstrain(array[,,,,,,] vector, array[,,,,,,] vector) => array[,,,,,,] vector + upper_bound_unconstrain(array[,,,,,,] row_vector, real) => array[,,,,,,] row_vector + upper_bound_unconstrain(array[,,,,,,] row_vector, array[,,,,,,] row_vector) => array[,,,,,,] row_vector + upper_bound_unconstrain(array[,,,,,,] matrix, real) => array[,,,,,,] matrix + upper_bound_unconstrain(array[,,,,,,] matrix, array[,,,,,,] matrix) => array[,,,,,,] matrix + upper_bound_unconstrain(array[,,,,,,,] real, real) => array[,,,,,,,] real + upper_bound_unconstrain(array[,,,,,,,] real, array[,,,,,,,] real) => array[,,,,,,,] real variance(vector) => real variance(row_vector) => real variance(matrix) => real