Add shrink-multiply op to backend (#402)

Add the tolerance-shrinking multiply operation to the backend, so it can
be done without generators which were constraining in terms of parameter
dataflow and syntactic boilerplate.

Renames the previous cancel_multiply (which was a bit too
implementation-focused) to shrink_multiply (which is more use-case
focused). Also better documentation in terms of target tolerance and
contributing tolerance.

Netlists should be the same, but there are ordering changes from changed
order of parts.

Resolves #393

Author: ducky64

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

@@ -56,6 +56,21 @@ object ExprEvaluate {
           case _ =>
             throw new ExprEvaluateException(s"Unknown binary operand types in $lhs ${binary.op} $rhs from $binary")
         }
+      case Op.SHRINK_MULT => (lhs, rhs) match {
+          case (RangeValue(targetMin, targetMax), RangeValue(contribMin, contribMax)) =>
+            val lower = contribMax * targetMin
+            val upper = contribMin * targetMax
+            if (lower > upper) { // TODO this should store a nonfatal error result instead of crashing on-the-spot
+              throw new ExprEvaluateException(s"Empty range result in $lhs ${binary.op} $rhs from $binary")
+            } else {
+              RangeValue(lower, upper)
+            }
+          case (RangeEmpty, RangeEmpty) => RangeEmpty
+          case (lhs: RangeValue, RangeEmpty) => RangeEmpty
+          case (RangeEmpty, rhs: RangeValue) => RangeEmpty
+          case _ =>
+            throw new ExprEvaluateException(s"Unknown binary operand types in $lhs ${binary.op} $rhs from $binary")
+        }
 
       case Op.AND => (lhs, rhs) match {
           case (BooleanValue(lhs), BooleanValue(rhs)) => BooleanValue(lhs && rhs)

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

@@ -39,6 +39,7 @@ class ExprToString() extends ValueExprMap[String] {
       def unapply(op: Op): Option[String] = op match {
         case Op.ADD => Some("+")
         case Op.MULT => Some("×")
+        case Op.SHRINK_MULT => Some("↓×")
         case Op.AND => Some("&&")
         case Op.OR => Some("||")
         case Op.XOR => Some("^")
@@ -59,7 +60,7 @@ class ExprToString() extends ValueExprMap[String] {
     }
     object PrefixOp {
       def unapply(op: Op): Option[String] = op match {
-        case Op.ADD | Op.MULT => None
+        case Op.ADD | Op.MULT | Op.SHRINK_MULT => None
         case Op.AND | Op.OR | Op.XOR | Op.IMPLIES | Op.EQ | Op.NEQ => None
         case Op.GT | Op.GTE | Op.LT | Op.LTE => None
         case Op.MAX => Some("max")

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

@@ -1,10 +1,10 @@
 package edg.compiler
 
+import edg.ExprBuilder._
+import edg.wir.DesignPath
 import org.scalatest._
 import org.scalatest.flatspec.AnyFlatSpec
-import matchers.should.Matchers._
-import edg.wir.DesignPath
-import edg.ExprBuilder._
+import org.scalatest.matchers.should.Matchers._
 
 class ExprEvaluateTest extends AnyFlatSpec {
   behavior.of("ExprEvaluate")
@@ -54,6 +54,30 @@ class ExprEvaluateTest extends AnyFlatSpec {
     ) should equal(FloatValue(2.0))
   }
 
+  it should "handle shrink multiply" in {
+    import edgir.expr.expr.BinaryExpr.Op
+    evalTest.map( // test x * 1/x = 1 property
+      ValueExpr.BinOp(
+        Op.SHRINK_MULT,
+        ValueExpr.Literal(10.0, 20.0),
+        ValueExpr.Literal(1.0 / 20, 1.0 / 10)
+      )) should equal(RangeValue(1.0, 1.0))
+    evalTest.map( // ... but with negative numbers
+      ValueExpr.BinOp(
+        Op.SHRINK_MULT,
+        ValueExpr.Literal(-20.0, -10.0),
+        ValueExpr.Literal(-1.0 / 10, -1.0 / 20)
+      )) should equal(RangeValue(1.0, 1.0))
+    val rcResult = evalTest.map( // test RC low pass filter, need to account for floating tolerance
+      ValueExpr.BinOp(
+        Op.SHRINK_MULT, // note, 2*pi and inverts flattened out, just becomes R*C
+        ValueExpr.Literal(90 * 1.0e-6 * 0.95, 110 * 1.0e-6 * 1.05),
+        ValueExpr.Literal(1.0 / 110, 1.0 / 90)
+      ))
+    rcResult.asInstanceOf[RangeValue].lower shouldBe ((1.0e-6f * 0.95f) +- 1.0e-12f)
+    rcResult.asInstanceOf[RangeValue].upper shouldBe ((1.0e-6f * 1.05f) +- 1.0e-12f)
+  }
+
   it should "handle unary arithmetic ops" in {
     import edgir.expr.expr.UnaryExpr.Op
     evalTest.map(
@@ -248,8 +272,8 @@ class ExprEvaluateTest extends AnyFlatSpec {
   }
 
   it should "handle array unary set ops" in {
-    import edgir.expr.expr.UnarySetExpr.Op
     import edg.ExprBuilder.Literal
+    import edgir.expr.expr.UnarySetExpr.Op
     evalTest.map(
       ValueExpr.UnarySetOp(
         Op.FLATTEN,
@@ -275,8 +299,8 @@ class ExprEvaluateTest extends AnyFlatSpec {
   }
 
   it should "handle array-value (broadcast) ops" in {
-    import edgir.expr.expr.BinarySetExpr.Op
     import edg.ExprBuilder.Literal
+    import edgir.expr.expr.BinarySetExpr.Op
     evalTest.map(
       ValueExpr.BinSetOp(
         Op.ADD,

edg/abstract_parts/OpampCircuits.py

@@ -313,42 +313,7 @@ def generate(self) -> None:
     self.assign(self.actual_ratio, self.rf.actual_resistance / self.r1.actual_resistance)
 
 
-class IntegratorValues(ESeriesRatioValue):
-  def __init__(self, factor: Range, capacitance: Range):
-    self.factor = factor  # output scale factor, 1/RC in units of 1/s
-    self.capacitance = capacitance  # value of the capacitor
-
-  @staticmethod
-  def from_resistors(r1_range: Range, r2_range: Range) -> 'IntegratorValues':
-    """r1 is the input resistor and r2 is the capacitor."""
-    return IntegratorValues(
-      1 / (r1_range * r2_range),
-      r2_range
-    )
-
-  def initial_test_decades(self) -> Tuple[int, int]:
-    """C is given per the spec, so we need factor = 1 / (R * C) => R = 1 / (factor * C)"""
-    capacitance_decade = ceil(log10(self.capacitance.center()))
-    allowed_resistances = Range.cancel_multiply(1 / self.capacitance, 1 / self.factor)
-    resistance_decade = ceil(log10(allowed_resistances.center()))
-
-    return resistance_decade, capacitance_decade
-
-  def distance_to(self, spec: 'IntegratorValues') -> List[float]:
-    if self.factor in spec.factor and self.capacitance in spec.capacitance:
-      return []
-    else:
-      return [
-        abs(self.factor.center() - spec.factor.center()),
-        abs(self.capacitance.center() - spec.capacitance.center())
-      ]
-
-  def intersects(self, spec: 'IntegratorValues') -> bool:
-    return self.factor.intersects(spec.factor) and \
-           self.capacitance.intersects(spec.capacitance)
-
-
-class IntegratorInverting(OpampApplication, KiCadSchematicBlock, KiCadImportableBlock, GeneratorBlock):
+class IntegratorInverting(OpampApplication, KiCadSchematicBlock, KiCadImportableBlock):
   """Opamp integrator, outputs the negative integral of the input signal, relative to some reference signal.
   Will clip to the input voltage rails.
 
@@ -384,7 +349,6 @@ def __init__(self, factor: RangeLike, capacitance: RangeLike, *,
 
     self.factor = self.ArgParameter(factor)  # output scale factor, 1/RC in units of 1/s
     self.capacitance = self.ArgParameter(capacitance)
-    self.generator_param(self.factor, self.capacitance)
 
     self.actual_factor = self.Parameter(RangeExpr())
 
@@ -396,10 +360,7 @@ def contents(self) -> None:
       " <b>of spec:</b> ", DescriptionString.FormatUnits(self.factor, "")
     )
 
-  def generate(self) -> None:
-    super().generate()
-
-    self.r = self.Block(Resistor(Range.cancel_multiply(1/self.get(self.capacitance), 1/self.get(self.factor))))
+    self.r = self.Block(Resistor((1/self.factor).shrink_multiply(1/self.capacitance)))
     self.c = self.Block(Capacitor(
       capacitance=self.capacitance,
       voltage=self.output.link().voltage

edg/abstract_parts/PassiveFilters.py

@@ -7,7 +7,7 @@
 from .Categories import *
 
 
-class LowPassRc(AnalogFilter, GeneratorBlock):
+class LowPassRc(AnalogFilter, Block):
   """Passive-typed low-pass RC specified by the resistor value (impedance) and -3dB (~70%) cutoff frequency."""
   @init_in_parent
   def __init__(self, impedance: RangeLike, cutoff_freq: RangeLike, voltage: RangeLike):
@@ -20,16 +20,13 @@ def __init__(self, impedance: RangeLike, cutoff_freq: RangeLike, voltage: RangeL
     self.cutoff_freq = self.ArgParameter(cutoff_freq)
     self.voltage = self.ArgParameter(voltage)
 
-    self.generator_param(self.impedance, self.cutoff_freq)
-
-  def generate(self) -> None:
-    super().generate()
+  def contents(self) -> None:
+    super().contents()
 
     self.r = self.Block(Resistor(resistance=self.impedance))  # TODO maybe support power?
-    # cutoff frequency is 1/(2 pi R C)
-    capacitance = Range.cancel_multiply(1 / (2 * pi * self.get(self.impedance)), 1 / self.get(self.cutoff_freq))
-
-    self.c = self.Block(Capacitor(capacitance=capacitance*Farad, voltage=self.voltage))
+    self.c = self.Block(Capacitor(  # cutoff frequency is 1/(2 pi R C)
+      capacitance=(1 / (2 * pi * self.cutoff_freq)).shrink_multiply(1 / self.impedance),
+      voltage=self.voltage))
     self.connect(self.input, self.r.a)
     self.connect(self.r.b, self.c.pos, self.output)  # TODO support negative voltages?
     self.connect(self.c.neg, self.gnd)

edg/abstract_parts/ResistiveDivider.py

@@ -172,14 +172,8 @@ class VoltageDivider(Analog, BaseVoltageDivider):
   @init_in_parent
   def __init__(self, *, output_voltage: RangeLike, impedance: RangeLike) -> None:
     super().__init__(impedance=impedance)
-
     self.output_voltage = self.ArgParameter(output_voltage)
-
-    ratio_lower = self.output_voltage.lower() / self.input.link().voltage.lower()
-    ratio_upper = self.output_voltage.upper() / self.input.link().voltage.upper()
-    self.require(ratio_lower <= ratio_upper,
-                   "can't generate divider to create output voltage of tighter tolerance than input voltage")
-    self.assign(self.ratio, (ratio_lower, ratio_upper))
+    self.assign(self.ratio, self.output_voltage.shrink_multiply(1/self.input.link().voltage))
 
 
 class VoltageSenseDivider(Analog, BaseVoltageDivider):
@@ -193,14 +187,8 @@ class VoltageSenseDivider(Analog, BaseVoltageDivider):
   @init_in_parent
   def __init__(self, *, full_scale_voltage: RangeLike, impedance: RangeLike) -> None:
     super().__init__(impedance=impedance)
-
     self.full_scale_voltage = self.ArgParameter(full_scale_voltage)
-
-    ratio_lower = self.full_scale_voltage.lower() / self.input.link().voltage.upper()
-    ratio_upper = self.full_scale_voltage.upper() / self.input.link().voltage.upper()
-    self.require(ratio_lower <= ratio_upper,
-                 "can't generate divider to create output voltage of tighter tolerance than input voltage")
-    self.assign(self.ratio, (ratio_lower, ratio_upper))
+    self.assign(self.ratio, self.full_scale_voltage / self.input.link().voltage.upper())
 
 
 class FeedbackVoltageDivider(Analog, BaseVoltageDivider):
@@ -213,10 +201,7 @@ def __init__(self, *, output_voltage: RangeLike, impedance: RangeLike,
 
     self.output_voltage = self.ArgParameter(output_voltage)
     self.assumed_input_voltage = self.ArgParameter(assumed_input_voltage)
-    self.actual_input_voltage = self.Parameter(RangeExpr(
-      (self.output_voltage.lower() / self.actual_ratio.upper(),
-       self.output_voltage.upper() / self.actual_ratio.lower())
-    ))
+    self.actual_input_voltage = self.Parameter(RangeExpr())
 
   def contents(self) -> None:
     super().contents()
@@ -227,11 +212,8 @@ def contents(self) -> None:
       "\n<b>impedance:</b> ", DescriptionString.FormatUnits(self.actual_impedance, "Ω"),
       " <b>of spec:</b> ", DescriptionString.FormatUnits(self.impedance, "Ω"))
 
-    ratio_lower = self.output_voltage.upper() / self.assumed_input_voltage.upper()
-    ratio_upper = self.output_voltage.lower() / self.assumed_input_voltage.lower()
-    self.require(ratio_lower <= ratio_upper,
-                 "can't generate feedback divider with input voltage of tighter tolerance than output voltage")
-    self.assign(self.ratio, (ratio_lower, ratio_upper))
+    self.assign(self.ratio, (1/self.assumed_input_voltage).shrink_multiply(self.output_voltage))
+    self.assign(self.actual_input_voltage, self.output_voltage / self.actual_ratio)
 
 
 class SignalDivider(Analog, Block):

edg/core/ArrayExpr.py

@@ -3,10 +3,10 @@
 from typing import *
 
 from .. import edgir
-from .Binding import EqOp, ArrayBinding
+from .Binding import EqOp, ArrayBinding, UnarySetOpBinding, BinarySetOpBinding
 from .ConstraintExpr import ConstraintExpr, IntLike, FloatExpr, FloatLike, RangeExpr, RangeLike, \
   BoolExpr, BoolLike, StringLike, \
-  NumericOp, BoolOp, RangeSetOp, Binding, UnarySetOpBinding, BinarySetOpBinding, StringExpr, IntExpr
+  NumericOp, BoolOp, RangeSetOp, Binding, StringExpr, IntExpr
 from .Core import Refable
 from .IdentityDict import IdentityDict
 from .Ports import BasePort

edg/core/Binding.py

@@ -29,6 +29,7 @@ class NumericOp(Enum):
   # Multiplicative
   mul = auto()
   invert = auto()
+  shrink_mul = auto()
 
 class BoolOp(Enum):
   op_and = auto()
@@ -316,6 +317,7 @@ def __init__(self,
       # Numeric
       NumericOp.add: edgir.BinaryExpr.ADD,
       NumericOp.mul: edgir.BinaryExpr.MULT,
+      NumericOp.shrink_mul: edgir.BinaryExpr.SHRINK_MULT,
       # Boolean
       BoolOp.op_and: edgir.BinaryExpr.AND,
       BoolOp.op_or: edgir.BinaryExpr.OR,

edg/core/ConstraintExpr.py

@@ -1,19 +1,19 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from functools import reduce
+from deprecated import deprecated
 from itertools import chain
 from typing import *
 
-from .. import edgir
 from .Binding import Binding, ParamBinding, BoolLiteralBinding, IntLiteralBinding, \
   FloatLiteralBinding, RangeLiteralBinding, StringLiteralBinding, RangeBuilderBinding, \
-  UnaryOpBinding, UnarySetOpBinding, BinaryOpBinding, BinarySetOpBinding, IfThenElseBinding
+  UnaryOpBinding, BinaryOpBinding, IfThenElseBinding
 from .Binding import NumericOp, BoolOp, EqOp, OrdOp, RangeSetOp
 from .Builder import builder
 from .Core import Refable
 from .IdentityDict import IdentityDict
 from .Range import Range
+from .. import edgir
 
 if TYPE_CHECKING:
   from .Ports import BasePort
@@ -362,13 +362,9 @@ def _from_lit(cls, pb: edgir.ValueLit) -> Range:
     return Range(pb.range.minimum.floating.val, pb.range.maximum.floating.val)
 
   @classmethod
+  @deprecated("Use shrink_multiply")
   def cancel_multiply(cls, input_side: RangeLike, output_side: RangeLike) -> RangeExpr:
-    """See Range.cancel_multiply"""
-    input_expr = cls._to_expr_type(input_side)
-    output_expr = cls._to_expr_type(output_side)
-    lower = input_expr.upper() * output_expr.lower()
-    upper = input_expr.lower() * output_expr.upper()
-    return cls._to_expr_type((lower, upper))  # rely on internally to check for non-empty range
+    return RangeExpr._to_expr_type(output_side).shrink_multiply(input_side)
 
   def __init__(self, initializer: Optional[RangeLike] = None) -> None:
     # must cast non-empty initializer type, because range supports wider initializers
@@ -448,6 +444,11 @@ def __truediv__(self, rhs: Union[RangeLike, FloatLike, IntLike]) -> RangeExpr:
       rhs_cast = self._to_expr_type(rhs)  # type: ignore
     return self * rhs_cast.__mul_inv__()
 
+  def shrink_multiply(self, contributing: RangeLike) -> RangeExpr:
+    """RangeExpr version of Range.shrink_multiply.
+    See docs for Range.shrink_multiply."""
+    return RangeExpr._create_binary_op(self, self._to_expr_type(contributing), NumericOp.shrink_mul)
+
   def abs(self) -> RangeExpr:
     """Returns a RangeExpr that is the absolute value of this.
     Intuitively, this returns a range that contains the absolute value of every point in the input."""