update to master and move mem_patterns tests to the compiler optims file

Author: SteveBronder

Jenkinsfile

@@ -29,11 +29,11 @@ pipeline {
     agent none
     parameters {
         booleanParam(name:"skip_end_to_end", defaultValue: false, description:"Skip end-to-end tests ")
-        string(defaultValue: '', name: 'cmdstan_pr',
+        string(defaultValue: 'develop', name: 'cmdstan_pr',
                description: "CmdStan PR to test against. Will check out this PR in the downstream Stan repo.")
-        string(defaultValue: '', name: 'stan_pr',
+        string(defaultValue: 'develop', name: 'stan_pr',
                description: "Stan PR to test against. Will check out this PR in the downstream Stan repo.")
-        string(defaultValue: '', name: 'math_pr',
+        string(defaultValue: 'develop', name: 'math_pr',
                description: "Math PR to test against. Will check out this PR in the downstream Math repo.")        
     }
     options {parallelsAlwaysFailFast()}
@@ -283,12 +283,15 @@ pipeline {
 
                         unstash 'ubuntu-exe'
 
-                        sh """
-                            git clone --recursive https://github.com/stan-dev/math.git
-                            cp bin/stanc math/test/expressions/stanc
-                        """
-
                         script {
+                            sh """
+                                git clone --recursive https://github.com/stan-dev/math.git
+                            """
+                            utils.checkout_pr("math", "math", params.math_pr)
+                            sh """
+                                cp bin/stanc math/test/expressions/stanc
+                            """
+
                             dir("math") {
                                 sh """
                                     echo O=0 >> make/local

src/middle/Stan_math_signatures.ml

@@ -271,7 +271,7 @@ let distributions =
   ; (full_lpdf, "student_t", [DVReal; DVReal; DVReal; DVReal], SoA)
   ; (full_lpdf, "std_normal", [DVReal], SoA)
   ; (full_lpdf, "uniform", [DVReal; DVReal; DVReal], SoA)
-  ; ([Lpdf; Rng], "von_mises", [DVReal; DVReal; DVReal], SoA)
+  ; (full_lpdf, "von_mises", [DVReal; DVReal; DVReal], SoA)
   ; (full_lpdf, "weibull", [DVReal; DVReal; DVReal], SoA)
   ; ([Lpdf], "wiener", [DVReal; DVReal; DVReal; DVReal; DVReal], SoA)
   ; ([Lpdf], "wishart", [DMatrix; DReal; DMatrix], SoA) ]
@@ -1688,6 +1688,16 @@ let () =
     , ReturnType UReal
     , [UVector; UMatrix; UVector; UVector; UReal]
     , AoS ) ;
+  add_unqualified
+    ( "normal_id_glm_lpdf"
+    , ReturnType UReal
+    , [UReal; UMatrix; UReal; UVector; UReal]
+    , AoS ) ;
+  add_unqualified
+    ( "normal_id_glm_lpdf"
+    , ReturnType UReal
+    , [UReal; UMatrix; UVector; UVector; UReal]
+    , AoS ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
@@ -1703,11 +1713,21 @@ let () =
     , ReturnType UReal
     , [UVector; URowVector; UReal; UVector; UVector]
     , AoS ) ;
+  add_unqualified
+    ( "normal_id_glm_lpdf"
+    , ReturnType UReal
+    , [UVector; URowVector; UVector; UVector; UReal]
+    , AoS ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UVector; URowVector; UVector; UVector; UVector]
     , AoS ) ;
+  add_unqualified
+    ( "normal_id_glm_lpdf"
+    , ReturnType UReal
+    , [UVector; URowVector; UReal; UVector; UReal]
+    , AoS ) ;
   add_nullary "not_a_number" ;
   add_unqualified ("num_elements", ReturnType UInt, [UMatrix], SoA) ;
   add_unqualified ("num_elements", ReturnType UInt, [UVector], SoA) ;

src/stan_math_backend/Expression_gen.ml

@@ -6,17 +6,9 @@ open Fmt
 let ends_with suffix s = String.is_suffix ~suffix s
 let starts_with prefix s = String.is_prefix ~prefix s
 
-let functions_requiring_namespace =
-  String.Set.of_list
-    [ "e"; "pi"; "log2"; "log10"; "sqrt2"; "not_a_number"; "positive_infinity"
-    ; "negative_infinity"; "machine_precision"; "abs"; "acos"; "acosh"; "asin"
-    ; "asinh"; "atan"; "atanh"; "cbrt"; "ceil"; "cos"; "cosh"; "erf"; "erfc"
-    ; "exp"; "exp2"; "expm1"; "fabs"; "floor"; "lgamma"; "log"; "log1p"; "log2"
-    ; "log10"; "round"; "sin"; "sinh"; "sqrt"; "tan"; "tanh"; "tgamma"; "trunc"
-    ; "fdim"; "fmax"; "fmin"; "hypot"; "fma"; "complex" ]
-
 let stan_namespace_qualify f =
-  if Set.mem functions_requiring_namespace f then "stan::math::" ^ f else f
+  if String.is_suffix ~suffix:"functor__" f || String.contains f ':' then f
+  else "stan::math::" ^ f
 
 (* return true if the types of the two expression are the same *)
 let types_match e1 e2 =
@@ -157,7 +149,7 @@ let fn_renames =
     ~f:(fun (k, v) -> (Internal_fun.to_string k, v))
     [ (Internal_fun.FnLength, "stan::math::size")
     ; (FnNegInf, "stan::math::negative_infinity")
-    ; (FnResizeToMatch, "resize_to_match")
+    ; (FnResizeToMatch, "stan::math::resize_to_match")
     ; (FnNaN, "std::numeric_limits<double>::quiet_NaN") ]
   |> String.Map.of_alist_exn
 
@@ -207,110 +199,86 @@ let transform_args = function
   | transform -> Transformation.fold (fun args arg -> args @ [arg]) [] transform
 
 let rec pp_index ppf = function
-  | Index.All -> pf ppf "index_omni()"
-  | Single e -> pf ppf "index_uni(%a)" pp_expr e
-  | Upfrom e -> pf ppf "index_min(%a)" pp_expr e
+  | Index.All -> pf ppf "stan::model::index_omni()"
+  | Single e -> pf ppf "stan::model::index_uni(%a)" pp_expr e
+  | Upfrom e -> pf ppf "stan::model::index_min(%a)" pp_expr e
   | Between (e_low, e_high) ->
-      pf ppf "index_min_max(%a, %a)" pp_expr e_low pp_expr e_high
-  | MultiIndex e -> pf ppf "index_multi(%a)" pp_expr e
+      pf ppf "stan::model::index_min_max(%a, %a)" pp_expr e_low pp_expr e_high
+  | MultiIndex e -> pf ppf "stan::model::index_multi(%a)" pp_expr e
 
 and pp_indexes ppf = function
   | [] -> pf ppf ""
   | idxs -> pf ppf "@[<hov 2>%a@]" (list ~sep:comma pp_index) idxs
 
 and pp_logical_op ppf op lhs rhs =
-  pf ppf "(primitive_value(@,%a)@ %s@ primitive_value(@,%a))" pp_expr lhs op
-    pp_expr rhs
+  pf ppf
+    "(stan::math::primitive_value(@,%a)@ %s@ stan::math::primitive_value(@,%a))"
+    pp_expr lhs op pp_expr rhs
 
 and pp_unary ppf fm es = pf ppf fm pp_expr (List.hd_exn es)
-and pp_binary ppf fm es = pf ppf fm pp_expr (first es) pp_expr (second es)
+
+and pp_binary_op ppf op es =
+  pf ppf "(%a@ %s@ %a)" pp_expr (first es) op pp_expr (second es)
 
 and pp_binary_f ppf f es =
   pf ppf "%s(@,%a,@ %a)" f pp_expr (first es) pp_expr (second es)
 
 and first es = List.nth_exn es 0
 and second es = List.nth_exn es 1
 
-and pp_scalar_binary ppf scalar_fmt generic_fmt es =
-  pp_binary ppf
-    ( if is_scalar (first es) && is_scalar (second es) then scalar_fmt
-    else generic_fmt )
-    es
+and pp_scalar_binary ppf op fn es =
+  if is_scalar (first es) && is_scalar (second es) then pp_binary_op ppf op es
+  else pp_binary_f ppf fn es
 
-and gen_operator_app op_expr =
-  match op_expr with
-  | Operator.Plus ->
-      fun ppf es -> pp_scalar_binary ppf "(%a@ +@ %a)" "add(@,%a,@ %a)" es
+and gen_operator_app op ppf es =
+  match op with
+  | Operator.Plus -> pp_scalar_binary ppf "+" "stan::math::add" es
   | PMinus ->
-      fun ppf es ->
-        pp_unary ppf
-          (if is_scalar (List.hd_exn es) then "-%a" else "minus(@,%a)")
-          es
-  | PPlus -> fun ppf es -> pp_unary ppf "%a" es
+      pp_unary ppf
+        (if is_scalar (List.hd_exn es) then "-%a" else "stan::math::minus(@,%a)")
+        es
+  | PPlus -> pp_unary ppf "%a" es
   | Transpose ->
-      fun ppf es ->
-        pp_unary ppf
-          (if is_scalar (List.hd_exn es) then "%a" else "transpose(@,%a)")
-          es
-  | PNot -> fun ppf es -> pp_unary ppf "logical_negation(@,%a)" es
-  | Minus ->
-      fun ppf es -> pp_scalar_binary ppf "(%a@ -@ %a)" "subtract(@,%a,@ %a)" es
-  | Times ->
-      fun ppf es -> pp_scalar_binary ppf "(%a@ *@ %a)" "multiply(@,%a,@ %a)" es
+      pp_unary ppf
+        ( if is_scalar (List.hd_exn es) then "%a"
+        else "stan::math::transpose(@,%a)" )
+        es
+  | PNot -> pp_unary ppf "stan::math::logical_negation(@,%a)" es
+  | Minus -> pp_scalar_binary ppf "-" "stan::math::subtract" es
+  | Times -> pp_scalar_binary ppf "*" "stan::math::multiply" es
   | Divide | IntDivide ->
-      fun ppf es ->
-        if
-          is_matrix (second es)
-          && (is_matrix (first es) || is_row_vector (first es))
-        then pp_binary_f ppf "mdivide_right" es
-        else pp_scalar_binary ppf "(%a@ /@ %a)" "divide(@,%a,@ %a)" es
-  | Modulo -> fun ppf es -> pp_binary_f ppf "modulus" es
-  | LDivide -> fun ppf es -> pp_binary_f ppf "mdivide_left" es
+      if
+        is_matrix (second es)
+        && (is_matrix (first es) || is_row_vector (first es))
+      then pp_binary_f ppf "stan::math::mdivide_right" es
+      else pp_scalar_binary ppf "/" "stan::math::divide" es
+  | Modulo -> pp_binary_f ppf "stan::math::modulus" es
+  | LDivide -> pp_binary_f ppf "stan::math::mdivide_left" es
   | And | Or ->
       Common.FatalError.fatal_error_msg
         [%message "And/Or should have been converted to an expression"]
-  | EltTimes ->
-      fun ppf es ->
-        pp_scalar_binary ppf "(%a@ *@ %a)" "elt_multiply(@,%a,@ %a)" es
-  | EltDivide ->
-      fun ppf es ->
-        pp_scalar_binary ppf "(%a@ /@ %a)" "elt_divide(@,%a,@ %a)" es
-  | Pow -> fun ppf es -> pp_binary_f ppf "pow" es
-  | EltPow -> fun ppf es -> pp_binary_f ppf "pow" es
-  | Equals -> fun ppf es -> pp_binary_f ppf "logical_eq" es
-  | NEquals -> fun ppf es -> pp_binary_f ppf "logical_neq" es
-  | Less -> fun ppf es -> pp_binary_f ppf "logical_lt" es
-  | Leq -> fun ppf es -> pp_binary_f ppf "logical_lte" es
-  | Greater -> fun ppf es -> pp_binary_f ppf "logical_gt" es
-  | Geq -> fun ppf es -> pp_binary_f ppf "logical_gte" es
+  | EltTimes -> pp_scalar_binary ppf "*" "stan::math::elt_multiply" es
+  | EltDivide -> pp_scalar_binary ppf "/" "stan::math::elt_divide" es
+  | Pow -> pp_binary_f ppf "stan::math::pow" es
+  | EltPow -> pp_binary_f ppf "stan::math::pow" es
+  | Equals -> pp_binary_f ppf "stan::math::logical_eq" es
+  | NEquals -> pp_binary_f ppf "stan::math::logical_neq" es
+  | Less -> pp_binary_f ppf "stan::math::logical_lt" es
+  | Leq -> pp_binary_f ppf "stan::math::logical_lte" es
+  | Greater -> pp_binary_f ppf "stan::math::logical_gt" es
+  | Geq -> pp_binary_f ppf "stan::math::logical_gte" es
 
 and gen_misc_special_math_app (f : string)
     (mem_pattern : Common.Helpers.mem_pattern)
     (ret_type : UnsizedType.returntype option) =
   match f with
   | "lmultiply" ->
-      Some (fun ppf es -> pp_binary ppf "multiply_log(@,%a,@ %a)" es)
+      Some (fun ppf es -> pp_binary_f ppf "stan::math::multiply_log" es)
   | "lchoose" ->
-      Some (fun ppf es -> pp_binary ppf "binomial_coefficient_log(@,%a,@ %a)" es)
-  | "target" -> Some (fun ppf _ -> pf ppf "get_lp(lp__, lp_accum__)")
-  | "get_lp" -> Some (fun ppf _ -> pf ppf "get_lp(lp__, lp_accum__)")
-  | "max" | "min" ->
-      Some
-        (fun ppf es ->
-          let f = match es with [_; _] -> "std::" ^ f | _ -> f in
-          pp_call ppf (f, pp_expr, es) )
-  | "ceil" ->
-      let std_prefix_data_scalar f = function
-        | [ Expr.
-              { Fixed.meta=
-                  Typed.Meta.{adlevel= DataOnly; type_= UInt | UReal; _}
-              ; _ } ] ->
-            "std::" ^ f
-        | _ -> f in
       Some
-        (fun ppf es ->
-          let f = std_prefix_data_scalar f es in
-          pp_call ppf (f, pp_expr, es) )
+        (fun ppf es -> pp_binary_f ppf "stan::math::binomial_coefficient_log" es)
+  | "target" -> Some (fun ppf _ -> pf ppf "stan::math::get_lp(lp__, lp_accum__)")
+  | "get_lp" -> Some (fun ppf _ -> pf ppf "stan::math::get_lp(lp__, lp_accum__)")
   | f when Map.mem fn_renames f ->
       Some (fun ppf es -> pp_call ppf (Map.find_exn fn_renames f, pp_expr, es))
   | "rep_matrix" | "rep_vector" | "rep_row_vector" | "append_row" | "append_col"
@@ -542,7 +510,8 @@ and pp_promoted ad ut ppf e =
           (local_scalar ut ad) pp_expr e )
 
 and pp_indexed ppf (vident, indices, pretty) =
-  pf ppf "@[<hov 2>rvalue(@,%s,@ %S,@ %a)@]" vident pretty pp_indexes indices
+  pf ppf "@[<hov 2>stan::model::rvalue(@,%s,@ %S,@ %a)@]" vident pretty
+    pp_indexes indices
 
 and pp_indexed_simple ppf (obj, idcs) =
   let idx_minus_one = function
@@ -569,7 +538,7 @@ and pp_expr ppf Expr.Fixed.({pattern; meta} as e) =
   match pattern with
   | Var s -> pf ppf "%s" s
   | Lit (Str, s) -> pf ppf "\"%s\"" (Cpp_str.escaped s)
-  | Lit (Imaginary, s) -> pf ppf "to_complex(0, %s)" s
+  | Lit (Imaginary, s) -> pf ppf "stan::math::to_complex(0, %s)" s
   | Lit ((Real | Int), s) -> pf ppf "%s" s
   | FunApp
       ( StanLib (op, _, _)
@@ -587,7 +556,6 @@ and pp_expr ppf Expr.Fixed.({pattern; meta} as e) =
       gen_fun_app suffix ppf f es mem_pattern ret_type
   | FunApp (CompilerInternal f, es) ->
       pp_compiler_internal_fn meta.adlevel meta.type_ f ppf es
-      (* stan_namespace_qualify?  *)
   | FunApp (UserDefined (f, suffix), es) ->
       pp_user_defined_fun ppf (f, suffix, es)
   | EAnd (e1, e2) -> pp_logical_op ppf "&&" e1 e2
@@ -675,7 +643,7 @@ let%expect_test "pp_expr9" =
 
 let%expect_test "pp_expr10" =
   printf "%s" (pp_unlocated (Indexed (dummy_locate (Var "a"), [All]))) ;
-  [%expect {| rvalue(a, "a", index_omni()) |}]
+  [%expect {| stan::model::rvalue(a, "a", stan::model::index_omni()) |}]
 
 let%expect_test "pp_expr11" =
   printf "%s"

src/stan_math_backend/Stan_math_code_gen.ml

@@ -114,7 +114,8 @@ let pp_returntype ppf arg_types rt =
 
 let pp_eigen_arg_to_ref ppf arg_types =
   let pp_ref ppf name =
-    pf ppf "@[<hv 8>const auto& %s = to_ref(%s);@]" name (name ^ "_arg__") in
+    pf ppf "@[<hv 8>const auto& %s = stan::math::to_ref(%s);@]" name
+      (name ^ "_arg__") in
   pf ppf "@[<v>%a@]@ " (list ~sep:cut pp_ref)
     (List.filter_map
        ~f:(fun (_, name, ut) ->
@@ -188,7 +189,7 @@ let get_templates_and_args exprs fdargs =
 let pp_template_decorator ppf = function
   | [] -> ()
   | templates ->
-      pf ppf "@[<hov>template <%a>@]@ " (list ~sep:comma string) templates
+      pf ppf "template @[<hov><%a>@]@ " (list ~sep:comma string) templates
 
 let mk_extra_args templates args =
   List.map ~f:(fun (t, v) -> t ^ "& " ^ v) (List.zip_exn templates args)
@@ -903,19 +904,9 @@ let pp_model ppf ({Program.prog_name; _} as p) =
     "%%NAME%%3 %%VERSION%%" stanc_args_to_print ;
   pf ppf "@ %a@]@]@ };" pp_model_public p
 
-(** The C++ aliases needed for the model class*)
 let usings =
   {|
-using stan::io::dump;
-using stan::model::assign;
-using stan::model::index_uni;
-using stan::model::index_max;
-using stan::model::index_min;
-using stan::model::index_min_max;
-using stan::model::index_multi;
-using stan::model::index_omni;
 using stan::model::model_base_crtp;
-using stan::model::rvalue;
 using namespace stan::math;
 |}