@pineforge/codegen-pyodide 1.3.0 → 1.4.0

package/pineforge_codegen/codegen/tables.py

@@ -565,6 +565,7 @@ NAME_ECHO_STRING_MEMBERS = {
 
 def _checked_array_index_prelude(
     *,
+    method: str,
     normalize_negative: bool = True,
     allow_size: bool = False,
     name: str = "index",
@@ -602,18 +603,18 @@ def _checked_array_index_prelude(
         f"using {raw_type}=std::decay_t<decltype({raw_value})>; "
         f"if constexpr(!std::is_same_v<{raw_type},bool>) {{ "
         f"if(is_na({raw_value})) "
-        "pine_runtime_error(std::string(\"Index na is out of bounds. Array size is \")+"
+        f'_PF_ARRAY_STOP("index_out_of_bounds", "{method}", std::string("Index na is out of bounds. Array size is ")+ '
         "std::to_string((int64_t)__pf_array.size())); } "
         f"if constexpr(std::is_floating_point_v<{raw_type}>) {{ "
         f"if(!std::isfinite({raw_value})) {{ "
         f"std::string {raw_text}={raw_value}>0?\"inf\":\"-inf\"; "
-        f"pine_runtime_error(std::string(\"Index \")+{raw_text}+"
+        f'_PF_ARRAY_STOP("index_out_of_bounds", "{method}", std::string("Index ")+{raw_text}+'
         "\" is out of bounds. Array size is \"+"
         "std::to_string((int64_t)__pf_array.size())); } "
         f"long double {raw_wide}=(long double){raw_value}; "
         f"if({raw_wide}<(long double)std::numeric_limits<int64_t>::min()||"
         f"{raw_wide}>(long double)std::numeric_limits<int64_t>::max()) "
-        "pine_runtime_error(std::string(\"Index \")+"
+        f'_PF_ARRAY_STOP("index_out_of_bounds", "{method}", std::string("Index ")+ '
         f"std::to_string((double){raw_value})+"
         "\" is out of bounds. Array size is \"+"
         "std::to_string((int64_t)__pf_array.size())); } "
@@ -621,12 +622,12 @@ def _checked_array_index_prelude(
         f"int64_t {size}=(int64_t)__pf_array.size(); "
         f"int64_t {checked}={checked_index}; "
         f"if({checked}<0||{checked}{upper}{size}) "
-        f"pine_runtime_error(std::string(\"Index \")+std::to_string({raw})+"
+        f'_PF_ARRAY_STOP("index_out_of_bounds", "{method}", std::string("Index ")+std::to_string({raw})+'
         f"\" is out of bounds. Array size is \"+std::to_string({size})); "
     )
 
 
-def _checked_array_range_prelude(*, reject_inverted: bool = True) -> str:
+def _checked_array_range_prelude(*, method: str, reject_inverted: bool = True) -> str:
     """Validate the half-open ``[index_from, index_to)`` range of fill/slice.
 
     Both endpoints are checked with ``allow_size`` (``index_to`` is exclusive,
@@ -637,14 +638,14 @@ def _checked_array_range_prelude(*, reject_inverted: bool = True) -> str:
     """
     return (
         _checked_array_index_prelude(
-            normalize_negative=False, allow_size=True, name="index_from"
+            method=method, normalize_negative=False, allow_size=True, name="index_from"
         )
         + _checked_array_index_prelude(
-            normalize_negative=False, allow_size=True, name="index_to"
+            method=method, normalize_negative=False, allow_size=True, name="index_to"
         )
         + (
             "if(__pf_array_index_from>__pf_array_index_to) "
-            "pine_runtime_error(\"Index 'from' should be less than index 'to'.\"); "
+            '_PF_ARRAY_STOP("slice_range_inverted", "slice", "Index \'from\' should be less than index \'to\'."); '
             if reject_inverted else ""
         )
     )
@@ -656,7 +657,7 @@ def _checked_array_insert(a: str, args: list[str], normalize_negative: bool = Tr
     ``index == size`` appends, so the bound is ``index <= size``; a negative
     index is end-relative, exactly as for ``get``/``set``/``remove``.
     """
-    check = _checked_array_index_prelude(allow_size=True,
+    check = _checked_array_index_prelude(method="insert", allow_size=True,
                                          normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array){ "
@@ -671,7 +672,7 @@ def _checked_array_insert(a: str, args: list[str], normalize_negative: bool = Tr
 
 def _checked_array_fill_range(a: str, args: list[str]) -> str:
     """``array.fill(id, value, index_from, index_to)`` — bounded range fill."""
-    check = _checked_array_range_prelude(reject_inverted=False)
+    check = _checked_array_range_prelude(method="fill", reject_inverted=False)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_array_value){ "
@@ -691,7 +692,7 @@ def checked_array_slice(a: str, args: list[str], *, result_type: str) -> str:
     ``result_type`` stays caller-supplied so the typed method lane keeps
     emitting the receiver's own element type; only the bounds checks are new.
     """
-    check = _checked_array_range_prelude()
+    check = _checked_array_range_prelude(method="slice")
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_raw_index_from_value){ "
@@ -704,7 +705,7 @@ def checked_array_slice(a: str, args: list[str], *, result_type: str) -> str:
 
 
 def _checked_array_get(a: str, args: list[str], normalize_negative: bool = True) -> str:
-    check = _checked_array_index_prelude(normalize_negative=normalize_negative)
+    check = _checked_array_index_prelude(method="get", normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array)->decltype(auto){ "
         "return [&](auto&& __pf_raw_index_value)->decltype(auto){ "
@@ -719,7 +720,7 @@ def _checked_array_get(a: str, args: list[str], normalize_negative: bool = True)
 
 
 def _checked_array_set(a: str, args: list[str], normalize_negative: bool = True) -> str:
-    check = _checked_array_index_prelude(normalize_negative=normalize_negative)
+    check = _checked_array_index_prelude(method="set", normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_raw_index_value){ "
@@ -731,7 +732,7 @@ def _checked_array_set(a: str, args: list[str], normalize_negative: bool = True)
 
 
 def _checked_array_remove(a: str, args: list[str], normalize_negative: bool = True) -> str:
-    check = _checked_array_index_prelude(normalize_negative=normalize_negative)
+    check = _checked_array_index_prelude(method="remove", normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_raw_index_value){ "
@@ -750,7 +751,7 @@ def _checked_array_end_get(a: str, method: str) -> str:
     access = "front" if method == "first" else "back"
     return (
         "[&](auto&& __pf_array)->decltype(auto){ "
-        f"if(__pf_array.empty()) pine_runtime_error(\"Cannot use {method}() "
+        f'if(__pf_array.empty()) _PF_ARRAY_STOP("empty_array_access", "{method}", "Cannot use {method}() '
         "if array is empty.\"); "
         "if constexpr(std::is_lvalue_reference_v<decltype(__pf_array)>) "
         f"return (__pf_array.{access}()); "
@@ -770,7 +771,7 @@ def _checked_array_end_remove(a: str, method: str) -> str:
     )
     return (
         "[&](auto&& __pf_array){ "
-        f"if(__pf_array.empty()) pine_runtime_error(\"Cannot use {method}() "
+        f'if(__pf_array.empty()) _PF_ARRAY_STOP("empty_array_access", "{method}", "Cannot use {method}() '
         "if array is empty.\"); "
         "using __pf_array_value_type=typename "
         "std::decay_t<decltype(__pf_array)>::value_type; "
@@ -781,7 +782,7 @@ def _checked_array_end_remove(a: str, method: str) -> str:
 
 def _checked_array_percentrank(a: str, args: list[str]) -> str:
     """Preserve degenerate results, then reject invalid PercentRank indices."""
-    check = _checked_array_index_prelude(normalize_negative=False)
+    check = _checked_array_index_prelude(method="percentrank", normalize_negative=False)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_raw_index_value){ "
@@ -822,7 +823,7 @@ ARRAY_METHODS = {
     "size":      lambda a, args: f"(double){a}.size()",
     "clear":     lambda a, args: f"{a}.clear()",
     "fill":      lambda a, args: f"std::fill({a}.begin(), {a}.end(), {args[0]})" if len(args) == 1
-                                 else _checked_array_fill_range(a, args),
+                                 else _checked_array_fill_range(a, args + [f"(int){a}.size()"] if len(args) == 2 else args),
     "includes":  lambda a, args: f"(std::find({a}.begin(), {a}.end(), {args[0]}) != {a}.end())",
     "indexof":   lambda a, args: f"[&](){{ auto __pf_it=std::find({a}.begin(),{a}.end(),{args[0]}); return __pf_it!={a}.end()?(double)(__pf_it-{a}.begin()):-1.0; }}()",
     "lastindexof": lambda a, args: f"[&](){{ for(int __pf_i=(int){a}.size()-1;__pf_i>=0;__pf_i--)if({a}[__pf_i]=={args[0]})return(double)__pf_i; return -1.0; }}()",
@@ -900,6 +901,9 @@ CHECKED_ARRAY_METHOD_KWARGS: dict[str, list[str]] = {
     "last": [],
     "pop": [],
     "shift": [],
+    "sort": ["order"],
+    "indexof": ["value"],
+    "unshift": ["value"],
 }
 
 MAP_METHODS = {
@@ -954,10 +958,109 @@ def _matrix_add_col(m: str, args: list) -> str:
     raise IndexError("matrix.add_col")
 
 
-# Keyword parameter order for matrix methods (Pine v6); used by ``_merge_kwargs``.
+def _matrix_sum(receiver: str, arguments: list[str]) -> str:
+    """Use the runtime's exposed Eigen arithmetic for matrix/scalar sums."""
+    if not arguments:
+        return f"{receiver}.sum()"
+    if len(arguments) != 1:
+        raise IndexError("matrix.sum")
+    return (
+        "([](const auto& _pf_sum_left, const auto& _pf_sum_right) { "
+        "auto _pf_sum_result = _pf_sum_left.copy(); "
+        "if constexpr (std::is_arithmetic_v<std::decay_t<decltype(_pf_sum_right)>>) { "
+        "_pf_sum_result.data().array() += _pf_sum_right; "
+        "} else { "
+        "if (_pf_sum_left.rows() != _pf_sum_right.rows() || "
+        "_pf_sum_left.columns() != _pf_sum_right.columns()) "
+        'throw std::runtime_error("Cannot sum matrices with different dimensions."); '
+        "_pf_sum_result.data() += _pf_sum_right.data(); "
+        "} return _pf_sum_result; "
+        f"}}({receiver}, {arguments[0]}))"
+    )
+
+
+def _matrix_submatrix(receiver: str, arguments: list[str]) -> str:
+    if len(arguments) > 4:
+        raise IndexError("matrix.submatrix")
+    if len(arguments) == 4 and all(argument is not None for argument in arguments):
+        return f"{receiver}.submatrix({', '.join(_matrix_int_arg(argument) for argument in arguments)})"
+    defaults = ["0", "_pf_matrix_target.rows()", "0", "_pf_matrix_target.columns()"]
+    arguments = arguments + [None] * (4 - len(arguments))
+    bounds = [argument if argument is not None else defaults[index]
+              for index, argument in enumerate(arguments)]
+    return ("[&](auto&& _pf_matrix_target) { return _pf_matrix_target.submatrix("
+            f"{', '.join(_matrix_int_arg(argument) for argument in bounds)}); }}({receiver})")
+
+
+# Parameter order of the matrix methods (Pine v6), receiver excluded: the
+# slots ``CallVisitor._collection_arg_nodes`` binds keyword arguments to. A
+# method absent here takes only its receiver. ``fill`` names its range
+# parameters so that a keyword one binds as a positional one does: the
+# lowering reads only ``value`` (the engine fills the whole matrix), a
+# pre-existing approximation of both spellings that the call does not refuse.
 MATRIX_METHOD_KWARGS: dict[str, list[str]] = {
-    "add_row": ["row_index", "array_id"],
-    "add_col": ["col_index", "array_id"],
+    "add_row": ["row", "array_id"],
+    "add_col": ["column", "array_id"],
+    "sort": ["column", "order"],
+    "submatrix": ["from_row", "to_row", "from_column", "to_column"],
+    "sum": ["id2"],
+    "diff": ["id2"],
+    "mult": ["id2"],
+    "get": ["row", "column"],
+    "set": ["row", "column", "value"],
+    "fill": ["value", "from_row", "to_row", "from_column", "to_column"],
+    "row": ["row"],
+    "col": ["column"],
+    "remove_row": ["row"],
+    "remove_col": ["column"],
+    "swap_rows": ["row1", "row2"],
+    "swap_columns": ["column1", "column2"],
+    "reshape": ["rows", "columns"],
+    "concat": ["id2", "vertical"],
+    "pow": ["power"],
+    "kron": ["id2"],
+}
+
+# Keyword spellings an earlier build bound that Pine's reference does not
+# name; they keep binding to the same slot.
+MATRIX_METHOD_KWARG_ALIASES: dict[str, dict[str, str]] = {
+    "add_row": {"row_index": "row"},
+    "add_col": {"col_index": "column"},
+}
+
+# The receiver's own keyword in the namespace form (``matrix.diff(id1=m, ...)``).
+MATRIX_RECEIVER_KEYWORD: dict[str, str] = {
+    "sum": "id1", "diff": "id1", "mult": "id1", "concat": "id1", "kron": "id1",
+}
+
+
+def _matrix_functional_receiver(method: str, node):
+    """The receiver node of ``matrix.<method>(...)``: its first positional
+    argument, else its keyword."""
+    return node.args[0] if node.args else node.kwargs.get(
+        MATRIX_RECEIVER_KEYWORD.get(method, "id"))
+
+
+# The optional parameters of the collection methods whose keywords bind by
+# position, and what a gap left before one stands for when only a later
+# keyword is written (``m.sort(order = order.descending)`` leaves ``column``
+# open): a number is Pine's default, ``None`` an omitted argument the method's
+# template defaults from the receiver's own extent (``_matrix_submatrix``'s
+# ``to_row`` / ``to_column``, the defaulted ``add_row`` / ``add_col`` of
+# ``TypeInferer._matrix_method_expr``). A parameter that is not listed is
+# required: a gap before it is refused.
+MATRIX_OPTIONAL_PARAMS: dict[str, dict[str, int | None]] = {
+    "sort": {"column": 0, "order": None},
+    "submatrix": {"from_row": 0, "to_row": None, "from_column": 0, "to_column": None},
+    "add_row": {"row": None, "array_id": None},
+    "add_col": {"column": None, "array_id": None},
+    "fill": {"from_row": None, "to_row": None, "from_column": None, "to_column": None},
+    "sum": {"id2": None},
+    "concat": {"vertical": None},
+}
+ARRAY_OPTIONAL_PARAMS: dict[str, dict[str, int | None]] = {
+    "fill": {"index_from": 0, "index_to": None},
+    "sort": {"order": None},
 }
 
 # Matrix mutators whose established C++ lowering returns ``void``.  A Pine
@@ -1024,17 +1127,17 @@ MATRIX_METHODS = {
     "swap_rows": lambda m, args: f"{m}.swap_rows({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])})",
     "swap_columns": lambda m, args: f"{m}.swap_columns({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])})",
     "copy":      lambda m, args: f"{m}.copy()",
-    "submatrix": lambda m, args: f"{m}.submatrix({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])}, {_matrix_int_arg(args[2])}, {_matrix_int_arg(args[3])})",
+    "submatrix": _matrix_submatrix,
     "reshape":   lambda m, args: f"{m}.reshape({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])})",
     "reverse":   lambda m, args: f"{m}.reverse()",
     "transpose": lambda m, args: f"{m}.transpose()",
-    "sort":      lambda m, args: f"{m}.sort({_matrix_int_arg(args[0])}, {args[1]} != \"descending\")" if len(args)>1 else f"{m}.sort({_matrix_int_arg(args[0])})",
+    "sort":      lambda m, args: f"{m}.sort({_matrix_int_arg(args[0])}, {args[1]} != \"descending\")" if len(args)>1 else f"{m}.sort({_matrix_int_arg(args[0])})" if args else f"{m}.sort(0)",
     "concat":    lambda m, args: f"{m}.concat({args[0]}, {pine_truth_cast(args[1])})" if len(args)>1 else f"{m}.concat({args[0]}, true)",
     "avg":       lambda m, args: f"{m}.avg()",
     "min":       lambda m, args: f"{m}.min()",
     "max":       lambda m, args: f"{m}.max()",
     "mode":      lambda m, args: f"{m}.mode()",
-    "sum":       lambda m, args: f"{m}.sum()",
+    "sum":       _matrix_sum,
     "diff":      lambda m, args: f"{m}.diff({args[0]})",
     "mult":      lambda m, args: f"{m}.mult({args[0]})",
     "pow":       lambda m, args: f"{m}.pow({_matrix_int_arg(args[0])})",
@@ -1128,10 +1231,11 @@ MATH_FUNC_MAP = {
 STR_FUNC_MAP = {
     "tostring":    None,  # handled separately (already works)
     "tonumber":    lambda args: (
-        f"[&](){{ "
-        f"try {{ return std::stod({args[0]}); }} "
-        f"catch (...) {{ return na<double>(); }} "
-        f"}}()"
+        f"[&](std::string _pf_number_text){{ "
+        f"try {{ return std::stod(_pf_number_text); }} "
+        f"catch (const std::invalid_argument&) {{ return na<double>(); }} "
+        f"catch (const std::out_of_range&) {{ return na<double>(); }} "
+        f"}}(({args[0]}))"
     ),
     "length":      lambda args: f"(int){args[0]}.length()",
     "contains":    lambda args: f"({args[0]}.find({args[1]}) != std::string::npos)",

package/pineforge_codegen/codegen/tv_number_format.py

@@ -60,7 +60,7 @@ static std::string _pf_tv_decimal(double value, int min_fraction,
     char buffer[128];
     const auto converted = std::to_chars(buffer, buffer + sizeof buffer, value);
     if (converted.ec != std::errc{})
-        throw std::runtime_error("shortest-decimal conversion failed");
+        _PF_ENGINE_INVARIANT("shortest-decimal conversion failed", std::runtime_error);
     std::string spelling(buffer, converted.ptr);
     const bool negative = !spelling.empty() && spelling[0] == '-';
     if (negative) spelling.erase(0, 1);
@@ -240,7 +240,14 @@ static std::string pine_str_format_tv(
             i = end + 1;
             continue;
         }
-        const size_t index = static_cast<size_t>(std::stoul(index_text));
+        size_t index = 0;
+        for (char _pf_digit : index_text) {
+            const size_t _pf_value = static_cast<size_t>(_pf_digit - '0');
+            if (index > (std::numeric_limits<size_t>::max() - _pf_value) / 10) {
+                _PF_STRING_STOP("format_index_overflow", "stoul");
+            }
+            index = index * 10 + _pf_value;
+        }
         if (index >= args.size()) {
             result += format_string.substr(i, end - i + 1);
             i = end + 1;

package/pineforge_codegen/codegen/types.py

@@ -46,6 +46,7 @@ from ..collection_history import history_annotation
 from ..errors import Phase
 from ..external_requests import UNPINNED_ANNOTATION
 from ..limits import iter_ast_nodes
+from ..matrix_overloads import matrix_sum_has_rhs
 from ..symbols import PineType, TypeSpec, method_receiver_type_name
 from .helpers import (
     NA_PRESERVING_INT_TYPES,
@@ -59,6 +60,7 @@ from .tables import (
     ARRAY_ARGS_READ_REPEATEDLY,
     ARRAY_DRAWING_NEW_CTORS,
     ARRAY_METHODS,
+    MATRIX_METHODS,
     V5_ARRAY_INDEX_METHODS,
     BAR_BUILTINS,
     BAR_FIELDS,
@@ -68,6 +70,7 @@ from .tables import (
     MATRIX_RETURNING_METHODS,
     PINE_TYPE_TO_CPP,
     TA_RETURNS_BOOL,
+    _matrix_functional_receiver,
     checked_array_slice,
 )
 
@@ -1776,8 +1779,10 @@ class TypeInferer:
                     if func_name in ("copy", "slice"):
                         return arg_spec
                     return arg_spec.element
-            if namespace == "matrix" and func_name in MATRIX_RETURNING_METHODS:
-                receiver_node = node.args[0] if node.args else node.kwargs.get("id")
+            if namespace == "matrix" and (func_name in MATRIX_RETURNING_METHODS or (
+                    func_name == "sum" and matrix_sum_has_rhs(node, namespace=True))):
+                receiver_node = (node.args[0] if node.args else
+                                 node.kwargs.get("id1", node.kwargs.get("id")))
                 receiver_spec = self._type_spec_from_expr(receiver_node)
                 if receiver_spec is not None and receiver_spec.kind == "matrix":
                     return receiver_spec
@@ -1869,7 +1874,8 @@ class TypeInferer:
                     method = (member_name
                               if history_annotation(node.callee.object) is not None
                               else func_name)
-                    if method in MATRIX_RETURNING_METHODS:
+                    if method in MATRIX_RETURNING_METHODS or (
+                            method == "sum" and matrix_sum_has_rhs(node)):
                         return recv_spec
                     if method in ("row", "col"):
                         return TypeSpec.array(recv_spec.element)
@@ -1961,6 +1967,70 @@ class TypeInferer:
     # Method lowering for collection types (used by visit_call paths)
     # ------------------------------------------------------------------
 
+    def _matrix_method_expr(self, receiver, method, arguments, argument_nodes, node):
+        functional = (isinstance(node.callee, MemberAccess)
+                      and isinstance(node.callee.object, Identifier)
+                      and node.callee.object.name == "matrix")
+        receiver_node = (_matrix_functional_receiver(method, node)
+                         if functional else node.callee.object)
+        receiver = self._checked_matrix_history_receiver(receiver, receiver_node)
+        if method in ("add_row", "add_col") and len(arguments) == 2 and arguments[0] is None:
+            # Only ``array_id`` is written (``m.add_row(array_id = a)``): the
+            # call is the array-only form, which appends it.
+            arguments = [arguments[1]]
+            argument_nodes = [argument_nodes[1]]
+        if method in ("add_row", "add_col") and len(arguments) < 2:
+            argument_spec = (self._type_spec_from_expr(argument_nodes[0])
+                             if argument_nodes else None)
+            # An index-only call: the argument is a number whose spec the
+            # analysis knows, or one it cannot type that reads as a number
+            # (a call, an input, ``bar_index % 2``): the generated lambda then
+            # tells an index from an array by the argument's C++ type.
+            typed_index = not arguments or (
+                argument_spec is not None and argument_spec.kind == "primitive")
+            untyped_number = (argument_spec is None and bool(arguments)
+                              and self._infer_type(argument_nodes[0]) in ("double", "int", "int64_t"))
+            receiver_spec = self._type_spec_from_expr(receiver_node)
+            if ((typed_index or untyped_number) and receiver_spec is not None
+                    and receiver_spec.element is not None):
+                element_spec = receiver_spec.element
+                element_cpp = self._type_spec_to_cpp(element_spec)
+                count = "columns" if method == "add_row" else "rows"
+                append = "rows" if method == "add_row" else "columns"
+                values = (f"std::vector<{element_cpp}>((size_t)_pf_matrix_target.{count}(), "
+                          f"{self._array_init_value_expr(element_spec, NaLiteral())})")
+                if untyped_number:
+                    inserted = MATRIX_METHODS[method]("_pf_matrix_target", ["_pf_matrix_arg", values])
+                    appended = MATRIX_METHODS[method]("_pf_matrix_target", ["_pf_matrix_arg"])
+                    return (
+                        "[&](auto&& _pf_matrix_target, auto&& _pf_matrix_arg) { "
+                        "if constexpr (std::is_arithmetic_v<std::decay_t<decltype(_pf_matrix_arg)>>) { "
+                        f"{inserted}; }} else {{ {appended}; }} }}({receiver}, {arguments[0]})")
+                index = arguments[0] if arguments else f"_pf_matrix_target.{append}()"
+                mutation = MATRIX_METHODS[method]("_pf_matrix_target", [index, values])
+                return f"[&](auto&& _pf_matrix_target) {{ {mutation}; }}({receiver})"
+        if method in ("sum", "diff", "mult") and argument_nodes:
+            other_spec = self._type_spec_from_expr(argument_nodes[0])
+            if (method == "mult" and other_spec is not None
+                    and other_spec.kind == "array"):
+                name = method
+                self._codegen_error(
+                    node, f"matrix.{name}(...) is not implemented in PineForge runtime.")
+            numeric_scalar = ((other_spec is not None and other_spec.kind == "primitive"
+                               and other_spec.name in ("int", "float"))
+                              or (other_spec is None and self._infer_type(argument_nodes[0])
+                                  in ("double", "int", "int64_t")))
+            if method in ("diff", "mult") and len(arguments) == 1 and numeric_scalar:
+                operation = "-=" if method == "diff" else "*="
+                return (
+                    "([](const auto& _pf_matrix_left, const auto _pf_matrix_right) { "
+                    "auto _pf_matrix_result = _pf_matrix_left.copy(); "
+                    f"_pf_matrix_result.data().array() {operation} _pf_matrix_right; "
+                    "return _pf_matrix_result; "
+                    f"}}({receiver}, {arguments[0]}))"
+                )
+        return MATRIX_METHODS[method](receiver, arguments)
+
     def _array_receiver_once_expr(
         self, array_expr: str, args: list[str], lower_receiver,
     ) -> str:
@@ -2004,6 +2074,10 @@ class TypeInferer:
         spec: TypeSpec | None = None, node: ASTNode | None = None,
     ) -> str:
         """Lower ``arr.method(...)`` to its C++ form, validating numeric requirements."""
+        if self._array_history_value_names():
+            array_expr = f"_pf_array_id({array_expr})"
+            if method in ("covariance", "concat") and args:
+                args = [f"_pf_array_id({args[0]})", *args[1:]]
         spec = spec or TypeSpec.array(TypeSpec.primitive("float"))
         arr_cpp_type = self._type_spec_to_cpp(spec)
         elem_cpp = self._type_spec_to_cpp(spec.element) if spec.element is not None else "double"
@@ -2103,7 +2177,10 @@ class TypeInferer:
                     )
                 return lowered
 
-        return self._array_receiver_once_expr(array_expr, args, lower_receiver)
+        try:
+            return self._array_receiver_once_expr(array_expr, args, lower_receiver)
+        except IndexError:
+            self._codegen_error(node, f"array.{method}: wrong number of arguments")
 
     def _map_method_expr(
         self, map_expr: str, method: str, args: list[str], spec: TypeSpec | None = None,
@@ -2150,6 +2227,10 @@ class TypeInferer:
 
     def _type_for_decl(self, node: VarDecl) -> str:
         """Determine the C++ type for a ``VarDecl``: explicit hint, then symbol, then RHS inference."""
+        history_value_cpp = (self._array_history_value_cpp_type(node.name)
+                             if not getattr(self, "_active_func_name", None) else None)
+        if history_value_cpp is not None:
+            return history_value_cpp
         def promote_wide_int(cpp_type: str) -> str:
             if cpp_type != "int":
                 return cpp_type