Reverse power flows, unified battery charging port

compiler/src/main/scala/edg/ExprBuilder.scala

@@ -133,6 +133,15 @@ object ExprBuilder {
       )
     }
 
+    def RangeEmpty(): lit.ValueLit = {
+      lit.ValueLit(`type` =
+        lit.ValueLit.Type.Range(lit.RangeLit(
+          minimum = Some(Floating(Float.NaN)),
+          maximum = Some(Floating(Float.NaN))
+        ))
+      )
+    }
+
     def Array(values: Seq[lit.ValueLit]): lit.ValueLit = {
       lit.ValueLit(`type` =
         lit.ValueLit.Type.Array(lit.ArrayLit(

compiler/src/main/scala/edg/compiler/Compiler.scala

@@ -117,7 +117,7 @@ class AssignNamer() {
 }
 
 object Compiler {
-  final val kExpectedProtoVersion = 8
+  final val kExpectedProtoVersion = 9
 }
 
 /** Compiler for a particular design, with an associated library to elaborate references from.

compiler/src/main/scala/edg/compiler/ExprEvaluate.scala

@@ -224,6 +224,16 @@ object ExprEvaluate {
     binarySet.op match {
       // Note promotion rules: range takes precedence, then float, then int
       // TODO: can we deduplicate these cases to delegate them to evalBinary?
+      case Op.EQ => (lhs, rhs) match {
+          case (lhss: ArrayValue[ExprValue] @unchecked, rhs: ExprValue) =>
+            val resultElts = lhss.values.map { arrayElt =>
+              evalBinary(expr.BinaryExpr(op = expr.BinaryExpr.Op.EQ), arrayElt, rhs)
+            }
+            ArrayValue(resultElts)
+          case _ => throw new ExprEvaluateException(
+              s"Unknown binary set operand types in $lhs ${binarySet.op} $rhs from $binarySet"
+            )
+        }
       case Op.ADD => (lhs, rhs) match {
           case (ArrayValue.ExtractRange(arrayElts), rhs: RangeType) =>
             val resultElts = arrayElts.map { arrayElt =>
@@ -363,6 +373,8 @@ object ExprEvaluate {
               evalUnary(expr.UnaryExpr(op = expr.UnaryExpr.Op.NEGATE), arrayElt)
             }
             ArrayValue(resultElts)
+          case ArrayValue.ExtractBoolean(arrayElts) =>
+            ArrayValue(arrayElts.map { arrayElt => BooleanValue(!arrayElt) })
           case _ => throw new ExprEvaluateException(s"Unknown unary set operand in ${unarySet.op} $vals from $unarySet")
         }
 

compiler/src/main/scala/edg/compiler/ExprToString.scala

@@ -82,6 +82,7 @@ class ExprToString() extends ValueExprMap[String] {
     import expr.BinarySetExpr.Op
     object InfixOp {
       def unapply(op: Op): Option[String] = op match {
+        case Op.EQ => Some("==")
         case Op.ADD => Some("+")
         case Op.MULT => Some("×")
         case Op.CONCAT => None
@@ -91,7 +92,7 @@ class ExprToString() extends ValueExprMap[String] {
     object PrefixOp {
       def unapply(op: Op): Option[String] = op match {
         case Op.CONCAT => Some("concat")
-        case Op.ADD | Op.MULT => None
+        case Op.EQ | Op.ADD | Op.MULT => None
         case Op.UNDEFINED | Op.Unrecognized(_) => None
       }
     }

compiler/src/test/scala/edg/compiler/ExprEvaluateTest.scala

@@ -300,6 +300,17 @@ class ExprEvaluateTest extends AnyFlatSpec {
   it should "handle array unary set ops" in {
     import edg.ExprBuilder.Literal
     import edgir.expr.expr.UnarySetExpr.Op
+    evalTest.map(
+      ValueExpr.UnarySetOp(
+        Op.NEGATE,
+        ValueExpr.Literal(Seq(
+          Literal.Boolean(false),
+          Literal.Boolean(true),
+          Literal.Boolean(false),
+        ))
+      )
+    ) should equal(ArrayValue(Seq(BooleanValue(true), BooleanValue(false), BooleanValue(true))))
+
     evalTest.map(
       ValueExpr.UnarySetOp(
         Op.FLATTEN,
@@ -327,6 +338,21 @@ class ExprEvaluateTest extends AnyFlatSpec {
   it should "handle array-value (broadcast) ops" in {
     import edg.ExprBuilder.Literal
     import edgir.expr.expr.BinarySetExpr.Op
+    evalTest.map(
+      ValueExpr.BinSetOp(
+        Op.EQ,
+        ValueExpr.Literal(Seq(Literal.Range(0, 10), Literal.Range(1, 11))),
+        ValueExpr.Literal(0, 10)
+      )
+    ) should equal(ArrayValue(Seq(BooleanValue(true), BooleanValue(false))))
+    evalTest.map(
+      ValueExpr.BinSetOp(
+        Op.EQ,
+        ValueExpr.Literal(Seq(Literal.Range(0, 10), Literal.RangeEmpty())),
+        ValueExpr.LiteralRangeEmpty()
+      )
+    ) should equal(ArrayValue(Seq(BooleanValue(false), BooleanValue(true))))
+
     evalTest.map(
       ValueExpr.BinSetOp(
         Op.ADD,

edg/abstract_parts/Categories.py

@@ -384,13 +384,6 @@ class PassiveComponent(DiscreteComponent):
     pass
 
 
-@abstract_block
-class DummyDevice(InternalBlock):
-    """Non-physical "device" used to affect parameters."""
-
-    pass
-
-
 @abstract_block
 class IdealModel(InternalBlock):
     """Ideal model device that can be used as a placeholder to get a design compiling

edg/abstract_parts/DummyDevices.py

@@ -10,31 +10,6 @@ def __init__(self) -> None:
         self.io = self.Port(Passive(), [InOut])
 
 
-class DummyGround(DummyDevice):
-    def __init__(self) -> None:
-        super().__init__()
-        self.gnd = self.Port(Ground(), [Common, InOut])
-
-
-class DummyVoltageSource(DummyDevice):
-    def __init__(self, voltage_out: RangeLike = RangeExpr.ZERO, current_limits: RangeLike = RangeExpr.ALL) -> None:
-        super().__init__()
-
-        self.pwr = self.Port(VoltageSource(voltage_out=voltage_out, current_limits=current_limits), [Power, InOut])
-
-        self.current_drawn = self.Parameter(RangeExpr(self.pwr.link().current_drawn))
-        self.voltage_limits = self.Parameter(RangeExpr(self.pwr.link().voltage_limits))
-
-
-class DummyVoltageSink(DummyDevice):
-    def __init__(self, voltage_limit: RangeLike = RangeExpr.ALL, current_draw: RangeLike = RangeExpr.ZERO) -> None:
-        super().__init__()
-
-        self.pwr = self.Port(VoltageSink(voltage_limits=voltage_limit, current_draw=current_draw), [Power, InOut])
-        self.voltage = self.Parameter(RangeExpr(self.pwr.link().voltage))
-        self.current_limits = self.Parameter(RangeExpr(self.pwr.link().current_limits))
-
-
 class DummyDigitalSource(DummyDevice):
     def __init__(self, voltage_out: RangeLike = RangeExpr.ZERO, current_limits: RangeLike = RangeExpr.ALL) -> None:
         super().__init__()

edg/abstract_parts/__init__.py

@@ -11,7 +11,6 @@
     PartsTableSelectorFootprint,
 )
 
-from .Categories import DummyDevice
 from .Categories import DiscreteComponent, DiscreteSemiconductor, PassiveComponent
 from .Categories import DiscreteApplication
 from .Categories import Analog, OpampApplication

edg/core/ArrayExpr.py

@@ -135,6 +135,9 @@ def hull(self) -> ArrayEltType:
 class ArrayBoolExpr(ArrayExpr[BoolExpr, List[bool], ArrayBoolLike]):
     _elt_type = BoolExpr
 
+    def __invert__(self) -> ArrayBoolExpr:
+        return self._new_bind(UnarySetOpBinding(self, BoolOp.op_not))
+
     def any(self) -> BoolExpr:
         return BoolExpr()._new_bind(UnarySetOpBinding(self, BoolOp.op_or))
 
@@ -179,6 +182,11 @@ def __rtruediv__(self, other: Union[FloatLike, RangeLike]) -> ArrayRangeExpr:
             self._create_unary_set_op(NumericOp.invert), RangeExpr._to_expr_type(other), NumericOp.mul
         )
 
+    def elts_equals(self, other: RangeLike) -> ArrayBoolExpr:
+        """Returns an ArrayBoolExpr of equality between each element of this and single-element other.
+        TODO: generalize to equality for other array types, needs some generic version of _to_expr_type"""
+        return ArrayBoolExpr()._new_bind(BinarySetOpBinding(self, RangeExpr._to_expr_type(other), EqOp.all_equal))
+
 
 ArrayStringLike = Union["ArrayStringExpr", Sequence[StringLike]]
 

edg/core/Binding.py

@@ -314,6 +314,7 @@ def __init__(self, src: ConstraintExpr, op: Union[NumericOp, BoolOp, EqOp, Range
             NumericOp.sum: edgir.UnarySetExpr.SUM,
             BoolOp.op_and: edgir.UnarySetExpr.ALL_TRUE,
             BoolOp.op_or: edgir.UnarySetExpr.ANY_TRUE,
+            BoolOp.op_not: edgir.UnarySetExpr.NEGATE,
             EqOp.all_equal: edgir.UnarySetExpr.ALL_EQ,
             EqOp.all_unique: edgir.UnarySetExpr.ALL_UNIQUE,
             RangeSetOp.min: edgir.UnarySetExpr.MINIMUM,
@@ -391,11 +392,12 @@ class BinarySetOpBinding(Binding):
     def __repr__(self) -> str:
         return f"BinaryOp({self.op}, ...)"
 
-    def __init__(self, lhset: ConstraintExpr, rhs: ConstraintExpr, op: NumericOp):
+    def __init__(self, lhset: ConstraintExpr, rhs: ConstraintExpr, op: Union[NumericOp, EqOp]):
         self.op_map = {
             # Numeric
             NumericOp.add: edgir.BinarySetExpr.ADD,
             NumericOp.mul: edgir.BinarySetExpr.MULT,
+            EqOp.all_equal: edgir.BinarySetExpr.EQ,
         }
 
         super().__init__()