refactor: rename _is_array_shape to is_array_shape

Author: AayushSabharwal

src/code.jl

@@ -13,7 +13,7 @@ import SymbolicUtils: @matchable, BasicSymbolic, Sym, Term, iscall, operation, a
                       symtype, sorted_arguments, metadata, isterm, term, maketerm, unwrap_const,
                       ArgsT, Const, SymVariant, _is_array_of_symbolics, _is_tuple_of_symbolics,
                       ArrayOp, isarrayop, IdxToAxesT, ROArgsT, shape, Unknown, ShapeVecT,
-                      search_variables!, _is_index_variable, RangesT, IDXS_SYM, _is_array_shape
+                      search_variables!, _is_index_variable, RangesT, IDXS_SYM, is_array_shape
 import SymbolicIndexingInterface: symbolic_type, NotSymbolic
 
 ##== state management ==##
@@ -153,7 +153,7 @@ function function_to_expr(::Type{ArrayOp{T}}, O::BasicSymbolic{T}, st) where {T}
     output_eltype = get(st.rewrites, :arrayop_eltype, Float64)
     delete!(st.rewrites, :arrayop_eltype)
     sh = shape(O)
-    default_output_buffer = if _is_array_shape(sh)
+    default_output_buffer = if is_array_shape(sh)
         term(zeros, output_eltype, size(O))
     else
         term(zero, output_eltype)
@@ -226,7 +226,7 @@ function inplace_expr(x::BasicSymbolic{T}, outsym) where {T}
     new_expr = unidealize_indices(x.expr, ranges, new_ranges)
     loopvar_order = unique!(filter(x -> x isa BasicSymbolic{T}, vcat(reverse(x.output_idx), collect(keys(ranges)), collect(keys(new_ranges)))))
 
-    if _is_array_shape(sh)
+    if is_array_shape(sh)
         inner_expr = SetArray(false, outsym, [AtIndex(term(CartesianIndex, x.output_idx...), term(x.reduce, term(getindex, outsym, x.output_idx...), new_expr))])
     else
         inner_expr = Assignment(outsym, term(x.reduce, outsym, new_expr))

src/methods.jl

@@ -223,8 +223,8 @@ for f in diadic
     f === NaNMath.pow && continue
     @eval function promote_shape(::$(typeof(f)), sh1::ShapeT, sh2::ShapeT)
         @nospecialize sh1 sh2
-        _is_array_shape(sh1) && _throw_array($f, sh1, sh2)
-        _is_array_shape(sh2) && _throw_array($f, sh1, sh2)
+        is_array_shape(sh1) && _throw_array($f, sh1, sh2)
+        is_array_shape(sh2) && _throw_array($f, sh1, sh2)
         return ShapeVecT()
     end
 end
@@ -246,7 +246,7 @@ for f in monadic
     else
         @eval function promote_shape(::$(typeof(f)), sh::ShapeT)
             @nospecialize sh
-            _is_array_shape(sh) && _throw_array($f, sh)
+            is_array_shape(sh) && _throw_array($f, sh)
             return ShapeVecT()
         end
     end
@@ -255,7 +255,7 @@ end
 error_f_symbolic(f, T) = error("$f is not defined for $T.")
 
 function promote_shape(::typeof(rem2pi), sha::ShapeT, shb::ShapeT)
-    _is_array_shape(sha) && _throw_array(rem2pi, sha, shb)
+    is_array_shape(sha) && _throw_array(rem2pi, sha, shb)
     ShapeVecT()
 end
 function Base.rem2pi(x::BasicSymbolic{T}, mode::Base.RoundingMode) where {T}
@@ -287,7 +287,7 @@ end
 function Base.inv(x::BasicSymbolic{T}) where {T}
     sh = shape(x)
     type = promote_symtype(inv, symtype(x))
-    if _is_array_shape(sh)
+    if is_array_shape(sh)
         return Term{T}(inv, ArgsT{T}((x,)); type = type, shape = sh)
     else
         return x ^ (-1)
@@ -381,7 +381,7 @@ function Base.adjoint(s::BasicSymbolic{T}) where {T}
     end
     sh = shape(s)
     stype = symtype(s)
-    if _is_array_shape(sh)
+    if is_array_shape(sh)
         type = promote_symtype(adjoint, stype)
         newsh = promote_shape(adjoint, sh)
         return Term{T}(adjoint, ArgsT{T}((s,)); type, shape = newsh)
@@ -493,7 +493,7 @@ function _ndims_from_shape(sh::ShapeT)
     end
 end
 Base.ndims(x::BasicSymbolic) = _ndims_from_shape(shape(x))
-Base.broadcastable(x::BasicSymbolic) = _is_array_shape(shape(x)) ? x : Ref(x)
+Base.broadcastable(x::BasicSymbolic) = is_array_shape(shape(x)) ? x : Ref(x)
 function Base.eachindex(x::BasicSymbolic)
     sh = shape(x)
     if sh isa Unknown
@@ -506,7 +506,7 @@ function Base.collect(x::BasicSymbolic)
 end
 function Base.iterate(x::BasicSymbolic)
     sh = shape(x)
-    _is_array_shape(sh) || return x, nothing
+    is_array_shape(sh) || return x, nothing
     idxs = eachindex(x)
     idx, state = iterate(idxs)
     return x[idx], (idxs, state)
@@ -530,12 +530,12 @@ promote_symtype(::Type{CartesianIndex}, xs...) = CartesianIndex{length(xs)}
 promote_symtype(::Type{CartesianIndex{N}}, xs::Vararg{T, N}) where {T, N} = CartesianIndex{N}
 function promote_shape(::Type{CartesianIndex}, xs::ShapeT...)
     @nospecialize xs
-    @assert all(!_is_array_shape, xs)
+    @assert all(!is_array_shape, xs)
     return ShapeVecT((1:length(xs),))
 end
 function promote_shape(::Type{CartesianIndex{N}}, xs::Vararg{ShapeT, N}) where {N}
     @nospecialize xs
-    @assert all(!_is_array_shape, xs)
+    @assert all(!is_array_shape, xs)
     return ShapeVecT((1:length(xs),))
 end
 function Base.CartesianIndex(x::BasicSymbolic{T}, xs::BasicSymbolic{T}...) where {T}
@@ -690,7 +690,7 @@ function _copy_broadcast!(buffer::BroadcastBuffer{T}, bc::Broadcast.Broadcasted{
 
     for arg in canonical_args
         sh = shape(arg)
-        is_arr = _is_array_shape(sh)
+        is_arr = is_array_shape(sh)
         if !is_arr
             push!(args, arg)
             continue
@@ -757,7 +757,7 @@ promote_symtype(::typeof(LinearAlgebra.dot), ::Type{T}, ::Type{S}) where {eT, T
 
 function LinearAlgebra.dot(x::BasicSymbolic{T}, y::BasicSymbolic{T}) where {T}
     shx = shape(x)
-    if _is_array_shape(shx)
+    if is_array_shape(shx)
         sh = promote_shape(LinearAlgebra.dot, shx, shape(y))
         type = promote_symtype(LinearAlgebra.dot, symtype(x), symtype(y))
         BSImpl.Term{T}(LinearAlgebra.dot, ArgsT{T}((x, y)); type, shape = sh)
@@ -994,7 +994,7 @@ function promote_symtype(::typeof(in), ::Type{T}, ::Type{S}) where {T, S}
 end
 function promote_shape(::typeof(in), sha::ShapeT, shb::ShapeT)
     @nospecialize sha shb
-    @assert _is_array_shape(shb) || throw(ArgumentError("Symbolic `in` requires an array as the second argument."))
+    @assert is_array_shape(shb) || throw(ArgumentError("Symbolic `in` requires an array as the second argument."))
     return ShapeVecT()
 end
 
@@ -1013,8 +1013,8 @@ function promote_symtype(::typeof(issubset), ::Type{T}, ::Type{S}) where {T <: A
 end
 function promote_shape(::typeof(issubset), sha::ShapeT, shb::ShapeT)
     @nospecialize sha shb
-    @assert _is_array_shape(sha) || throw(ArgumentError("Symbolic `issubset` requires arrays as both arguments."))
-    @assert _is_array_shape(shb) || throw(ArgumentError("Symbolic `issubset` requires arrays as both arguments."))
+    @assert is_array_shape(sha) || throw(ArgumentError("Symbolic `issubset` requires arrays as both arguments."))
+    @assert is_array_shape(shb) || throw(ArgumentError("Symbolic `issubset` requires arrays as both arguments."))
     return ShapeVecT()
 end
 
@@ -1036,8 +1036,8 @@ for f in [union, intersect]
     end
     @eval function promote_shape(::$(typeof(f)), sha::ShapeT, shb::ShapeT)
         @nospecialize sha shb
-        @assert _is_array_shape(sha) || throw(ArgumentError("Symbolic `$($f)` requires arrays as both arguments."))
-        @assert _is_array_shape(shb) || throw(ArgumentError("Symbolic `$($f)` requires arrays as both arguments."))
+        @assert is_array_shape(sha) || throw(ArgumentError("Symbolic `$($f)` requires arrays as both arguments."))
+        @assert is_array_shape(shb) || throw(ArgumentError("Symbolic `$($f)` requires arrays as both arguments."))
         return Unknown(1)
     end
     for T1 in [AbstractArray, :(BasicSymbolic{T})], T2 in [AbstractArray, :(BasicSymbolic{T})]
@@ -1064,8 +1064,8 @@ function promote_symtype(::typeof(binomial), ::Type{T}, ::Type{S}) where {T <: N
 end
 function promote_shape(::typeof(binomial), sha::ShapeT, shb::ShapeT)
     @nospecialize sha shb
-    _is_array_shape(sha) && _throw_array(sha)
-    _is_array_shape(shb) && _throw_array(shb)
+    is_array_shape(sha) && _throw_array(sha)
+    is_array_shape(shb) && _throw_array(shb)
 
     return ShapeVecT()
 end

src/substitute.jl

@@ -309,7 +309,7 @@ function _default_scalarize(f, x::BasicSymbolic{T}, ::Val{toplevel}) where {T, t
     @nospecialize f
 
     sh = shape(x)
-    _is_array_shape(sh) && return [x[idx] for idx in eachindex(x)]
+    is_array_shape(sh) && return [x[idx] for idx in eachindex(x)]
 
     args = arguments(x)
     if toplevel
@@ -324,7 +324,7 @@ function scalarize(x::BasicSymbolic{T}, ::Val{toplevel} = Val{false}()) where {T
     sh isa Unknown && return x
     @match x begin
         BSImpl.Const(;) => return x
-        BSImpl.Sym(;) => _is_array_shape(sh) ? [x[idx] for idx in eachindex(x)] : x
+        BSImpl.Sym(;) => is_array_shape(sh) ? [x[idx] for idx in eachindex(x)] : x
         BSImpl.ArrayOp(; output_idx, expr, term, ranges, reduce) => begin
             term === nothing || return scalarize(term, Val{toplevel}())
             subrules = Dict()

src/types.jl

@@ -2190,11 +2190,11 @@ end
     """))
 end
 
-_is_array_shape(sh::ShapeT) = sh isa Unknown || _ndims_from_shape(sh) > 0
+is_array_shape(sh::ShapeT) = sh isa Unknown || _ndims_from_shape(sh) > 0
 function _multiplied_shape(shapes)
-    first_arr = findfirst(_is_array_shape, shapes)
+    first_arr = findfirst(is_array_shape, shapes)
     first_arr === nothing && return ShapeVecT(), first_arr
-    last_arr::Int = findlast(_is_array_shape, shapes)
+    last_arr::Int = findlast(is_array_shape, shapes)
     first_arr == last_arr && return shapes[first_arr], first_arr
 
     sh1::ShapeT = shapes[first_arr]
@@ -2218,7 +2218,7 @@ function _multiplied_shape(shapes)
     for i in (first_arr + 1):last_arr
         sh = shapes[i]
         ndims_sh = _ndims_from_shape(sh)
-        _is_array_shape(sh) || continue
+        is_array_shape(sh) || continue
         ndims_sh <= 2 || throw_expected_matvec(shend)
         is_matmatmul || throw_incompatible_shapes(cur_shape, sh)
         is_matmatmul = ndims_sh != 1
@@ -2266,9 +2266,9 @@ end
 
 function _split_arrterm_scalar_coeff(::Type{T}, ex::BasicSymbolic{T}) where {T}
     sh = shape(ex)
-    _is_array_shape(sh) || return ex, one_of_vartype(T)
+    is_array_shape(sh) || return ex, one_of_vartype(T)
     @match ex begin
-        BSImpl.Term(; f, args, type) && if f === (*) && !_is_array_shape(shape(first(args))) end => begin
+        BSImpl.Term(; f, args, type) && if f === (*) && !is_array_shape(shape(first(args))) end => begin
             if length(args) == 2
                 return args[1], args[2]
             end
@@ -2399,7 +2399,7 @@ function (mwb::MulWorkerBuffer{T})(terms) where {T}
         end
         sh = shape(term)
         type = promote_symtype(*, type, symtype(term))
-        if _is_array_shape(sh)
+        if is_array_shape(sh)
             coeff, arrterm = _split_arrterm_scalar_coeff(T, term)
             _mul_worker!(T, num_coeff, den_coeff, num_dict, den_dict, coeff)
             if iscall(arrterm) && operation(arrterm) === (*)
@@ -2730,7 +2730,7 @@ function _bslash_worker(::Type{T}, a, b) where {T}
     sha = shape(a)
     type = promote_symtype(\, symtype(a), symtype(b))
     newshape = promote_shape(\, shape(a), shape(b))
-    if _is_array_shape(newshape) || _is_array_shape(sha)
+    if is_array_shape(newshape) || is_array_shape(sha)
         # Scalar \ Anything == Anything / Scalar
         return Term{T}(\, ArgsT{T}((a, b)); type, shape = newshape)
     else
@@ -2828,7 +2828,7 @@ function ^(a::BasicSymbolic{T}, b) where {T <: Union{SymReal, SafeReal}}
     newshape = promote_shape(^, sha, shb)
     type = promote_symtype(^, symtype(a), symtype(b))
 
-    if _is_array_shape(sha)
+    if is_array_shape(sha)
         @match a begin
             BSImpl.Term(; f, args) && if f === (^) && isconst(args[1]) end => begin
                 base, exp = args
@@ -2843,7 +2843,7 @@ function ^(a::BasicSymbolic{T}, b) where {T <: Union{SymReal, SafeReal}}
             end
             _ => return Term{T}(^, ArgsT{T}((a, Const{T}(b))); type, shape = newshape)
         end
-    elseif _is_array_shape(shb)
+    elseif is_array_shape(shb)
         return Term{T}(^, ArgsT{T}((a, Const{T}(b))); type, shape = newshape)::BasicSymbolic{T}
     end
     if b isa Number
@@ -2907,7 +2907,7 @@ function ^(a::Union{Number, Matrix{<:Number}}, b::BasicSymbolic{T}) where {T}
     isconst(b) && return Const{T}(a ^ unwrap_const(b))
     newshape = promote_shape(^, shape(a), shape(b))
     type = promote_symtype(^, symtype(a), symtype(b))
-    if _is_array_shape(newshape) && _isone(a)
+    if is_array_shape(newshape) && _isone(a)
         if newshape isa Unknown
             return Const{T}(LinearAlgebra.I)
         else
@@ -2973,7 +2973,7 @@ function promote_shape(::typeof(getindex), sharr::ShapeT, shidxs::ShapeVecT...)
     @nospecialize sharr
     # `promote_symtype` rules out the presence of multidimensional indices - each index
     # is either an integer, Colon or vector of integers.
-    _is_array_shape(sharr) || isempty(shidxs) || throw_not_array(sharr)
+    is_array_shape(sharr) || isempty(shidxs) || throw_not_array(sharr)
     result = ShapeVecT()
     for (i, idx) in enumerate(shidxs)
         isempty(idx) && continue
@@ -3027,7 +3027,7 @@ Base.@propagate_inbounds function _getindex(arr::BasicSymbolic{T}, idxs::Union{B
             idxs_i = 1
             for oldidx in Iterators.drop(args, 1)
                 oldidx_sh = shape(oldidx)
-                if !_is_array_shape(oldidx_sh)
+                if !is_array_shape(oldidx_sh)
                     push!(newargs, oldidx)
                     continue
                 end
@@ -3111,7 +3111,7 @@ Base.@propagate_inbounds function _getindex(arr::BasicSymbolic{T}, idxs::Union{B
             end
         end
         _ => begin
-            if _is_array_shape(newshape)
+            if is_array_shape(newshape)
                 new_output_idx = OutIdxT{T}()
                 expr_args = ArgsT{T}((arr,))
                 term_args = ArgsT{T}((arr,))