rename At to EvalAt

Author: vyudu

src/ModelingToolkit.jl

@@ -142,7 +142,7 @@ function var_derivative_graph! end
 include("bipartite_graph.jl")
 using .BipartiteGraphs
 
-export At
+export EvalAt
 include("variables.jl")
 include("parameters.jl")
 include("independent_variables.jl")

src/variables.jl

@@ -616,11 +616,11 @@ getshift(x::Symbolic) = Symbolics.getmetadata(x, VariableShift, 0)
 ###################
 ### Evaluate at ###
 ###################
-struct At <: Symbolics.Operator
+struct EvalAt <: Symbolics.Operator
     t::Union{Symbolic, Number}
 end
 
-function (A::At)(x::Symbolic)
+function (A::EvalAt)(x::Symbolic)
     if symbolic_type(x) == NotSymbolic() || !iscall(x)
         if x isa Symbolics.CallWithMetadata
             return x(A.t)
@@ -637,18 +637,18 @@ function (A::At)(x::Symbolic)
         A(x)
     else
         length(arguments(x)) !== 1 &&
-            error("Variable $x has too many arguments. At can only be applied to one-argument variables.")
+            error("Variable $x has too many arguments. EvalAt can only be applied to one-argument variables.")
         (symbolic_type(only(arguments(x))) !== ScalarSymbolic()) && return x
         return operation(x)(A.t)
     end
 end
 
-function (A::At)(x::Union{Num, Symbolics.Arr})
+function (A::EvalAt)(x::Union{Num, Symbolics.Arr})
     wrap(A(unwrap(x)))
 end
-SymbolicUtils.isbinop(::At) = false
+SymbolicUtils.isbinop(::EvalAt) = false
 
-Base.nameof(::At) = :At
-Base.show(io::IO, A::At) = print(io, "At(", A.t, ")")
-Base.:(==)(A1::At, A2::At) = isequal(A1.t, A2.t)
-Base.hash(A::At, u::UInt) = hash(A.t, u)
+Base.nameof(::EvalAt) = :EvalAt
+Base.show(io::IO, A::EvalAt) = print(io, "EvalAt(", A.t, ")")
+Base.:(==)(A1::EvalAt, A2::EvalAt) = isequal(A1.t, A2.t)
+Base.hash(A::EvalAt, u::UInt) = hash(A.t, u)

test/model_parsing.jl

@@ -1037,12 +1037,12 @@ end
             x ~ y
         end
         @constraints begin
-            At(0.3)(x) ~ 3
+            EvalAt(0.3)(x) ~ 3
             y ≲ 4
         end
         @costs begin
             x + y
-            At(1)(y)^2
+            EvalAt(1)(y)^2
         end
         @consolidate f(u) = u[1]^2 + log(u[2])
     end
@@ -1053,8 +1053,8 @@ end
     costs = ModelingToolkit.get_costs(ex)
     constrs = ModelingToolkit.get_constraints(ModelingToolkit.get_constraintsystem(ex))
     @test isequal(costs[1], ex.x + ex.y)
-    @test isequal(costs[2], At(1)(ex.y)^2)
-    @test isequal(constrs[1], -3 + At(0.3)(ex.x) ~ 0)
+    @test isequal(costs[2], EvalAt(1)(ex.y)^2)
+    @test isequal(constrs[1], -3 + EvalAt(0.3)(ex.x) ~ 0)
     @test isequal(constrs[2], -4 + ex.y ≲ 0)
     @test ModelingToolkit.get_consolidate(ex)([1, 2]) ≈ 1 + log(2)
 end

test/variable_utils.jl

@@ -164,23 +164,23 @@ end
     @variables x(t) v(..) w(t)[1:3]
     @parameters y z(u, t) r[1:3]
 
-    @test At(1)(x) isa Num
-    @test isequal(At(1)(y), y)
-    @test_throws ErrorException At(1)(z)
-    @test isequal(At(1)(v), v(1))
-    @test isequal(At(1)(v(t)), v(1))
-    @test isequal(At(1)(v(2)), v(2))
+    @test EvalAt(1)(x) isa Num
+    @test isequal(EvalAt(1)(y), y)
+    @test_throws ErrorException EvalAt(1)(z)
+    @test isequal(EvalAt(1)(v), v(1))
+    @test isequal(EvalAt(1)(v(t)), v(1))
+    @test isequal(EvalAt(1)(v(2)), v(2))
 
-    arr = At(1)(w)
-    var = At(1)(w[1])
+    arr = EvalAt(1)(w)
+    var = EvalAt(1)(w[1])
     @test arr isa Symbolics.Arr
     @test var isa Num
 
-    @test isequal(At(1)(r), r)
-    @test isequal(At(1)(r[2]), r[2])
+    @test isequal(EvalAt(1)(r), r)
+    @test isequal(EvalAt(1)(r[2]), r[2])
 
     _x = ModelingToolkit.unwrap(x)
-    @test At(1)(_x) isa Symbolics.BasicSymbolic
-    @test only(arguments(At(1)(_x))) == 1
-    @test At(1)(D(x)) isa Num
+    @test EvalAt(1)(_x) isa Symbolics.BasicSymbolic
+    @test only(arguments(EvalAt(1)(_x))) == 1
+    @test EvalAt(1)(D(x)) isa Num
 end