feat: add and use global Const(1) and Const(0) values

Author: AayushSabharwal

src/methods.jl

@@ -701,7 +701,7 @@ function _copy_broadcast!(buffer::BroadcastBuffer{T}, bc::Broadcast.Broadcasted{
             # unknown ndims, assume full shape
             limit = sh.ndims == -1 ? ndim : sh.ndims
             for i in 1:limit
-                push!(getindex_args,  length(bc.axes[i]) == 1 ? Const{T}(1) : subscripts[i])
+                push!(getindex_args,  length(bc.axes[i]) == 1 ? one_of_vartype(T) : subscripts[i])
             end
         elseif sh isa ShapeVecT
             for (i, (target_ax, cur_ax)) in enumerate(zip(bc.axes, sh))

src/polyform.jl

@@ -258,7 +258,7 @@ function quick_cancel(x::S, y::S)::Tuple{S, S} where {T <: SymVariant, S <: Basi
     elseif opy === (*) && !isconst(x)
         return reverse(quick_mul(y, x))
     elseif isequal(x, y)
-        return Const{T}(1), Const{T}(1)
+        return one_of_vartype(T), one_of_vartype(T)
     else
         return x, y
     end
@@ -269,7 +269,7 @@ function quick_pow(x::S, y::S)::Tuple{S, S} where {T <: SymVariant, S <: BasicSy
     base, exp = arguments(x)
     exp = unwrap_const(exp)
     exp isa Number || return (x, y)
-    isequal(base, y) && exp >= 1 ? (base ^ (exp - 1), Const{T}(1)) : (x, y)
+    isequal(base, y) && exp >= 1 ? (base ^ (exp - 1), one_of_vartype(T)) : (x, y)
 end
 
 # Double Pow case
@@ -281,17 +281,17 @@ function quick_powpow(x::S, y::S)::Tuple{S, S} where {T <: SymVariant, S <: Basi
     exp2 = unwrap_const(exp2)
     !(exp1 isa Number && exp2 isa Number) && return (x, y)
     if exp1 > exp2
-        return base1 ^ (exp1 - exp2), Const{T}(1)
+        return base1 ^ (exp1 - exp2), one_of_vartype(T)
     elseif exp1 == exp2
-        return Const{T}(1), Const{T}(1)
+        return one_of_vartype(T), one_of_vartype(T)
     else # exp1 < exp2
-        return Const{T}(1), base2 ^ (exp2 - exp1)
+        return one_of_vartype(T), base2 ^ (exp2 - exp1)
     end
 end
 
 # ismul(x)
 function quick_mul(x::S, y::S)::Tuple{S, S} where {T <: SymVariant, S <: BasicSymbolic{T}}
-    yy = BSImpl.Term{T}(^, ArgsT{T}((y, Const{T}(1))); type = symtype(y))
+    yy = BSImpl.Term{T}(^, ArgsT{T}((y, one_of_vartype(T))); type = symtype(y))
     newx, newy = quick_mulpow(x, yy)
     return isequal(newy, yy) ? (x, y) : (newx, newy)
 end
@@ -326,12 +326,12 @@ function quick_mulpow(x::S, y::S)::Tuple{S, S} where {T <: SymVariant, S <: Basi
     oldval = args[idx]
     if argexp > exp
         args[idx] = argbase ^ (argexp - exp)
-        result = mul_worker(T, args), Const{T}(1)
+        result = mul_worker(T, args), one_of_vartype(T)
     elseif argexp == exp
-        args[idx] = Const{T}(1)
-        result = mul_worker(T, args), Const{T}(1)
+        args[idx] = one_of_vartype(T)
+        result = mul_worker(T, args), one_of_vartype(T)
     else
-        args[idx] = Const{T}(1)
+        args[idx] = one_of_vartype(T)
         result = mul_worker(T, args), base ^ (exp - argexp)
     end
     args[idx] = oldval

src/types.jl

@@ -870,13 +870,33 @@ function hashcons(s::BSImpl.Type)
     end true
 end
 
-const SMALLV_DEFAULT_SYMREAL = hashcons(BSImpl.Const{SymReal}(0, 0, nothing))
-const SMALLV_DEFAULT_SAFEREAL = hashcons(BSImpl.Const{SafeReal}(0, 0, nothing))
-const SMALLV_DEFAULT_TREEREAL = hashcons(BSImpl.Const{TreeReal}(0, 0, nothing))
+const CONST_ZERO_SYMREAL = hashcons(BSImpl.Const{SymReal}(0, 0, nothing))
+const CONST_ZERO_SAFEREAL = hashcons(BSImpl.Const{SafeReal}(0, 0, nothing))
+const CONST_ZERO_TREEREAL = hashcons(BSImpl.Const{TreeReal}(0, 0, nothing))
+const CONST_ONE_SYMREAL = hashcons(BSImpl.Const{SymReal}(1, 0, nothing))
+const CONST_ONE_SAFEREAL = hashcons(BSImpl.Const{SafeReal}(1, 0, nothing))
+const CONST_ONE_TREEREAL = hashcons(BSImpl.Const{TreeReal}(1, 0, nothing))
 
-defaultval(::Type{BasicSymbolic{SymReal}}) = SMALLV_DEFAULT_SYMREAL
-defaultval(::Type{BasicSymbolic{SafeReal}}) = SMALLV_DEFAULT_SAFEREAL
-defaultval(::Type{BasicSymbolic{TreeReal}}) = SMALLV_DEFAULT_TREEREAL
+@inline defaultval(::Type{BasicSymbolic{SymReal}}) =  CONST_ZERO_SYMREAL
+@inline defaultval(::Type{BasicSymbolic{SafeReal}}) = CONST_ZERO_SAFEREAL
+@inline defaultval(::Type{BasicSymbolic{TreeReal}}) = CONST_ZERO_TREEREAL
+
+"""
+    $(TYPEDSIGNATURES)
+
+Return a `Const` representing `0` with the provided `vartype`.
+"""
+@inline zero_of_vartype(::Type{SymReal}) = CONST_ZERO_SYMREAL
+@inline zero_of_vartype(::Type{SafeReal}) = CONST_ZERO_SAFEREAL
+@inline zero_of_vartype(::Type{TreeReal}) = CONST_ZERO_TREEREAL
+"""
+    $(TYPEDSIGNATURES)
+
+Return a `Const` representing `1` with the provided `vartype`.
+"""
+@inline one_of_vartype(::Type{SymReal}) = CONST_ONE_SYMREAL
+@inline one_of_vartype(::Type{SafeReal}) = CONST_ONE_SAFEREAL
+@inline one_of_vartype(::Type{TreeReal}) = CONST_ONE_TREEREAL
 
 function get_mul_coefficient(x)
     iscall(x) && operation(x) === (*) || throw(ArgumentError("$x is not a multiplication"))
@@ -1151,7 +1171,7 @@ end
     if isempty(dict)
         return Const{T}(coeff)
     elseif _iszero(coeff)
-        return Const{T}(0)
+        return zero_of_vartype(T)
     elseif _isone(coeff) && length(dict) == 1
         k, v = first(dict)
         if _isone(v)
@@ -2057,7 +2077,7 @@ function (awb::AddWorkerBuffer{T})(terms::Union{Tuple{Vararg{BasicSymbolic{T}}},
     if !all(_numeric_or_arrnumeric_symtype, terms)
         throw(MethodError(+, Tuple(terms)))
     end
-    isempty(terms) && return Const{T}(0)
+    isempty(terms) && return zero_of_vartype(T)
     if isone(length(terms))
         return Const{T}(only(terms))
     end
@@ -2246,7 +2266,7 @@ end
 
 function _split_arrterm_scalar_coeff(::Type{T}, ex::BasicSymbolic{T}) where {T}
     sh = shape(ex)
-    _is_array_shape(sh) || return ex, Const{T}(1)
+    _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
             if length(args) == 2
@@ -2264,7 +2284,7 @@ function _split_arrterm_scalar_coeff(::Type{T}, ex::BasicSymbolic{T}) where {T}
             coeff, rest = @match expr begin
                 BSImpl.Term(; f, args, type, shape) && if f === (*) end => begin
                     if query!(isequal(idxs_for_arrayop(T)), args[1])
-                        Const{T}(1), expr
+                        one_of_vartype(T), expr
                     elseif length(args) == 2
                         args[1], args[2]
                     else
@@ -2274,7 +2294,7 @@ function _split_arrterm_scalar_coeff(::Type{T}, ex::BasicSymbolic{T}) where {T}
                         _coeff, BSImpl.Term{T}(*, newargs; type, shape)
                     end
                 end
-                _ => (Const{T}(1), expr)
+                _ => (one_of_vartype(T), expr)
             end
             if term === nothing
                 termrest = nothing
@@ -2284,15 +2304,15 @@ function _split_arrterm_scalar_coeff(::Type{T}, ex::BasicSymbolic{T}) where {T}
             end
             return coeff, BSImpl.ArrayOp{T}(output_idx, rest, reduce, termrest, ranges; shape, type)
         end
-        _ => (Const{T}(1), ex)
+        _ => (one_of_vartype(T), ex)
     end
 end
-_split_arrterm_scalar_coeff(::Type{T}, ex) where {T} = Const{T}(1), Const{T}(ex)
+_split_arrterm_scalar_coeff(::Type{T}, ex) where {T} = one_of_vartype(T), Const{T}(ex)
 
 function _as_base_exp(term::BasicSymbolic{T}) where {T}
     @match term begin
         BSImpl.Term(; f, args) && if f === (^) && isconst(args[2]) end => (args[1], args[2])
-        _ => (term, Const{T}(1))
+        _ => (term, one_of_vartype(T))
     end
 end
 
@@ -2355,7 +2375,7 @@ function (mwb::MulWorkerBuffer{T})(terms) where {T}
     if !all(x -> _is_array_of_symbolics(x) || _numeric_or_arrnumeric_symtype(x), terms)
         throw(MethodError(*, Tuple(terms)))
     end
-    isempty(terms) && return Const{T}(1)
+    isempty(terms) && return one_of_vartype(T)
     length(terms) == 1 && return Const{T}(terms[1])
     empty!(mwb)
     newshape = _multiplied_terms_shape(terms)
@@ -2827,7 +2847,7 @@ function ^(a::BasicSymbolic{T}, b) where {T <: Union{SymReal, SafeReal}}
         return Term{T}(^, ArgsT{T}((a, Const{T}(b))); type, shape = newshape)::BasicSymbolic{T}
     end
     if b isa Number
-        iszero(b) && return Const{T}(1)
+        iszero(b) && return one_of_vartype(T)
         isone(b) && return Const{T}(a)
     end
     if b isa Real && b < 0