simplify

Author: blegat

src/graph_tools.jl

@@ -409,10 +409,8 @@ function _compute_hessian_sparsity(
                         nodes[r].index,
                     )
                 elseif nodes[r].type == NODE_VARIABLE_BLOCK
-                    # `NODE_VARIABLE_BLOCK` would need its block shape to
-                    # enumerate the variable indices. Hessian sparsity for
-                    # block-variable expressions is a follow-up; for now we
-                    # error so the gradient-only path stays correct.
+                    # TODO `NODE_VARIABLE_BLOCK` would need its block shape to
+                    # enumerate the variable indices.
                     error(
                         "Internal error: Hessian sparsity for " *
                         "NODE_VARIABLE_BLOCK is not yet supported.",

src/parse_moi.jl

@@ -143,76 +143,38 @@ function _parse_moi_stack!(
     ::Vector{Tuple{Int,Any}},
     ::Model,
     expr::Expression,
-    x::ArrayOfContiguousVariables{2},
+    x::ArrayOfContiguousVariables,
     parent_index::Int,
 )
-    m, n = x.size
     # Emit a single block node. The block represents the contiguous range of
-    # `m * n` MOI variable indices `x.offset+1 .. x.offset+m*n`, laid out in
-    # column-major order (matching `Matrix{Float64}` and `Base.LinearIndices`),
+    # MOI variable indices `x.offset+1, ...`, laid out in
+    # column-major order (matching `Array{Float64}` and `Base.LinearIndices`),
     # which is the layout `_view_array` will see at evaluation time.
     push!(
         expr.nodes,
         Node(NODE_MOI_VARIABLE_BLOCK, x.offset + 1, parent_index),
     )
-    expr.block_shapes[length(expr.nodes)] = [m, n]
-    return
-end
-
-function _parse_moi_stack!(
-    stack::Vector{Tuple{Int,Any}},
-    data::Model,
-    expr::Expression,
-    x::ArrayOfContiguousVariables{1},
-    parent_index::Int,
-)
-    m = x.size[1]
-    vect_id = data.operators.multivariate_operator_to_id[:vect]
-    push!(expr.nodes, Node(NODE_CALL_MULTIVARIATE, vect_id, parent_index))
-    vect_idx = length(expr.nodes)
-    for i in m:-1:1
-        vi = MOI.VariableIndex(x.offset + i)
-        push!(stack, (vect_idx, vi))
-    end
+    expr.block_shapes[length(expr.nodes)] = collect(x.size)
     return
 end
 
-# ── Constant matrices and vectors ────────────────────────────────────────────
+# ── Constant arrays ────────────────────────────────────────────
 
 function _parse_moi_stack!(
     ::Vector{Tuple{Int,Any}},
     ::Model,
-    expr::Expression{T},
-    x::AbstractMatrix{<:Real},
+    expr::Expression,
+    x::AbstractArray{<:Real},
     parent_index::Int,
-) where {T}
-    m, n = size(x)
-    # Emit a single value block. We push the `m * n` flat values to
-    # `expr.values` in column-major order (matching `Matrix{Float64}`'s memory
+)
+    # Emit a single value block. We push the flat values to
+    # `expr.values` in column-major order (matching `Array{Float64}`'s memory
     # layout); `node.index` records the start of that contiguous range so
     # `_SubexpressionStorage` can copy it into the tape in one block at
     # construction time.
     start_idx = length(expr.values) + 1
-    for j in 1:n, i in 1:m
-        push!(expr.values, convert(T, x[i, j]))
-    end
+    append!(expr.values, x)
     push!(expr.nodes, Node(NODE_VALUE_BLOCK, start_idx, parent_index))
-    expr.block_shapes[length(expr.nodes)] = [m, n]
-    return
-end
-
-function _parse_moi_stack!(
-    stack::Vector{Tuple{Int,Any}},
-    data::Model,
-    expr::Expression,
-    x::AbstractVector{<:Real},
-    parent_index::Int,
-)
-    vect_id = data.operators.multivariate_operator_to_id[:vect]
-    push!(expr.nodes, Node(NODE_CALL_MULTIVARIATE, vect_id, parent_index))
-    vect_idx = length(expr.nodes)
-    for i in length(x):-1:1
-        push!(stack, (vect_idx, x[i]))
-    end
+    expr.block_shapes[length(expr.nodes)] = collect(size(x))
     return
 end