code: def test_Interval_arithmetic():
      i12cc = SetExpr(Interval(1, 2))
      i12lo = SetExpr(Interval.Lopen(1, 2))
      i12ro = SetExpr(Interval.Ropen(1, 2))
      i12o = SetExpr(Interval.open(1, 2))
  
      n23cc = SetExpr(Interval(-2, 3))
      n23lo = SetExpr(Interval.Lopen(-2, 3))
      n23ro = SetExpr(Interval.Ropen(-2, 3))
      n23o = SetExpr(Interval.open(-2, 3))
  
      n3n2cc = SetExpr(Interval(-3, -2))
  
      assert i12cc + i12cc == SetExpr(Interval(2, 4))
      assert i12cc - i12cc == SetExpr(Interval(-1, 1))
      assert i12cc * i12cc == SetExpr(Interval(1, 4))
      assert i12cc / i12cc == SetExpr(Interval(S.Half, 2))
      assert i12cc**2 == SetExpr(Interval(1, 4))
      assert i12cc**3 == SetExpr(Interval(1, 8))
  
      assert i12lo + i12ro == SetExpr(Interval.open(2, 4))
      assert i12lo - i12ro == SetExpr(Interval.Lopen(-1, 1))
      assert i12lo * i12ro == SetExpr(Interval.open(1, 4))
      assert i12lo / i12ro == SetExpr(Interval.Lopen(S.Half, 2))
      assert i12lo + i12lo == SetExpr(Interval.Lopen(2, 4))
      assert i12lo - i12lo == SetExpr(Interval.open(-1, 1))
      assert i12lo * i12lo == SetExpr(Interval.Lopen(1, 4))
      assert i12lo / i12lo == SetExpr(Interval.open(S.Half, 2))
      assert i12lo + i12cc == SetExpr(Interval.Lopen(2, 4))
      assert i12lo - i12cc == SetExpr(Interval.Lopen(-1, 1))
      assert i12lo * i12cc == SetExpr(Interval.Lopen(1, 4))
      assert i12lo / i12cc == SetExpr(Interval.Lopen(S.Half, 2))
      assert i12lo + i12o == SetExpr(Interval.open(2, 4))
      assert i12lo - i12o == SetExpr(Interval.open(-1, 1))
      assert i12lo * i12o == SetExpr(Interval.open(1, 4))
      assert i12lo / i12o == SetExpr(Interval.open(S.Half, 2))
      assert i12lo**2 == SetExpr(Interval.Lopen(1, 4))
      assert i12lo**3 == SetExpr(Interval.Lopen(1, 8))
  
      assert i12ro + i12ro == SetExpr(Interval.Ropen(2, 4))
      assert i12ro - i12ro == SetExpr(Interval.open(-1, 1))
      assert i12ro * i12ro == SetExpr(Interval.Ropen(1, 4))
      assert i12ro / i12ro == SetExpr(Interval.open(S.Half, 2))
      assert i12ro + i12cc == SetExpr(Interval.Ropen(2, 4))
      assert i12ro - i12cc == SetExpr(Interval.Ropen(-1, 1))
      assert i12ro * i12cc == SetExpr(Interval.Ropen(1, 4))
      assert i12ro / i12cc == SetExpr(Interval.Ropen(S.Half, 2))
      assert i12ro + i12o == SetExpr(Interval.open(2, 4))
      assert i12ro - i12o == SetExpr(Interval.open(-1, 1))
      assert i12ro * i12o == SetExpr(Interval.open(1, 4))
      assert i12ro / i12o == SetExpr(Interval.open(S.Half, 2))
      assert i12ro**2 == SetExpr(Interval.Ropen(1, 4))
      assert i12ro**3 == SetExpr(Interval.Ropen(1, 8))
  
      assert i12o + i12lo == SetExpr(Interval.open(2, 4))
      assert i12o - i12lo == SetExpr(Interval.open(-1, 1))
      assert i12o * i12lo == SetExpr(Interval.open(1, 4))
      assert i12o / i12lo == SetExpr(Interval.open(S.Half, 2))
      assert i12o + i12ro == SetExpr(Interval.open(2, 4))
      assert i12o - i12ro == SetExpr(Interval.open(-1, 1))
      assert i12o * i12ro == SetExpr(Interval.open(1, 4))
      assert i12o / i12ro == SetExpr(Interval.open(S.Half, 2))
      assert i12o + i12cc == SetExpr(Interval.open(2, 4))
      assert i12o - i12cc == SetExpr(Interval.open(-1, 1))
      assert i12o * i12cc == SetExpr(Interval.open(1, 4))
      assert i12o / i12cc == SetExpr(Interval.open(S.Half, 2))
      assert i12o**2 == SetExpr(Interval.open(1, 4))
      assert i12o**3 == SetExpr(Interval.open(1, 8))
  
      assert n23cc + n23cc == SetExpr(Interval(-4, 6))
      assert n23cc - n23cc == SetExpr(Interval(-5, 5))
      assert n23cc * n23cc == SetExpr(Interval(-6, 9))
      assert n23cc / n23cc == SetExpr(Interval.open(-oo, oo))
      assert n23cc + n23ro == SetExpr(Interval.Ropen(-4, 6))
      assert n23cc - n23ro == SetExpr(Interval.Lopen(-5, 5))
      assert n23cc * n23ro == SetExpr(Interval.Ropen(-6, 9))
      assert n23cc / n23ro == SetExpr(Interval.Lopen(-oo, oo))
      assert n23cc + n23lo == SetExpr(Interval.Lopen(-4, 6))
      assert n23cc - n23lo == SetExpr(Interval.Ropen(-5, 5))
      assert n23cc * n23lo == SetExpr(Interval(-6, 9))
      assert n23cc / n23lo == SetExpr(Interval.open(-oo, oo))
      assert n23cc + n23o == SetExpr(Interval.open(-4, 6))
      assert n23cc - n23o == SetExpr(Interval.open(-5, 5))
      assert n23cc * n23o == SetExpr(Interval.open(-6, 9))
      assert n23cc / n23o == SetExpr(Interval.open(-oo, oo))
      assert n23cc**2 == SetExpr(Interval(0, 9))
      assert n23cc**3 == SetExpr(Interval(-8, 27))
  
      n32cc = SetExpr(Interval(-3, 2))
      n32lo = SetExpr(Interval.Lopen(-3, 2))
      n32ro = SetExpr(Interval.Ropen(-3, 2))
      assert n32cc * n32lo == SetExpr(Interval.Ropen(-6, 9))
      assert n32cc * n32cc == SetExpr(Interval(-6, 9))
      assert n32lo * n32cc == SetExpr(Interval.Ropen(-6, 9))
      assert n32cc * n32ro == SetExpr(Interval(-6, 9))
      assert n32lo * n32ro == SetExpr(Interval.Ropen(-6, 9))
      assert n32cc / n32lo == SetExpr(Interval.Ropen(-oo, oo))
      assert i12cc / n32lo == SetExpr(Interval.Ropen(-oo, oo))
  
      assert n3n2cc**2 == SetExpr(Interval(4, 9))
      assert n3n2cc**3 == SetExpr(Interval(-27, -8))
  
      assert n23cc + i12cc == SetExpr(Interval(-1, 5))
      assert n23cc - i12cc == SetExpr(Interval(-4, 2))
      assert n23cc * i12cc == SetExpr(Interval(-4, 6))
      assert n23cc / i12cc == SetExpr(Interval(-2, 3))
  
imports: from sympy.sets.setexpr import SetExpr
  from sympy.sets import Interval, FiniteSet, Intersection, ImageSet, Union
  from sympy.core.expr import Expr
  from sympy.core.function import Lambda
  from sympy.core.numbers import I, Rational, oo
  from sympy.core.singleton import S
  from sympy.core.symbol import Dummy, Symbol, symbols
  from sympy.functions.elementary.exponential import exp, log
  from sympy.functions.elementary.miscellaneous import Max, Min, sqrt
  from sympy.functions.elementary.trigonometric import cos
  from sympy.sets.sets import Set
label_desc: Use image node_id 11 for calling a global function with example usage: test_Interval_arithmetic() without return types