class_docstr: Represents a piecewise function.
  
  Usage:
  
    Piecewise( (expr,cond), (expr,cond), ... )
      - Each argument is a 2-tuple defining an expression and condition
      - The conds are evaluated in turn returning the first that is True.
        If any of the evaluated conds are not explicitly False,
        e.g. ``x < 1``, the function is returned in symbolic form.
      - If the function is evaluated at a place where all conditions are False,
        nan will be returned.
      - Pairs where the cond is explicitly False, will be removed and no pair
        appearing after a True condition will ever be retained. If a single
        pair with a True condition remains, it will be returned, even when
        evaluation is False.
  
  Examples
  ========
  
  >>> from sympy import Piecewise, log, piecewise_fold
  >>> from sympy.abc import x, y
  >>> f = x**2
  >>> g = log(x)
  >>> p = Piecewise((0, x < -1), (f, x <= 1), (g, True))
  >>> p.subs(x,1)
  1
  >>> p.subs(x,5)
  log(5)
  
  Booleans can contain Piecewise elements:
  
  >>> cond = (x < y).subs(x, Piecewise((2, x < 0), (3, True))); cond
  Piecewise((2, x < 0), (3, True)) < y
  
  The folded version of this results in a Piecewise whose
  expressions are Booleans:
  
  >>> folded_cond = piecewise_fold(cond); folded_cond
  Piecewise((2 < y, x < 0), (3 < y, True))
  
  When a Boolean containing Piecewise (like cond) or a Piecewise
  with Boolean expressions (like folded_cond) is used as a condition,
  it is converted to an equivalent :class:`~.ITE` object:
  
  >>> Piecewise((1, folded_cond))
  Piecewise((1, ITE(x < 0, y > 2, y > 3)))
  
  When a condition is an ``ITE``, it will be converted to a simplified
  Boolean expression:
  
  >>> piecewise_fold(_)
  Piecewise((1, ((x >= 0) | (y > 2)) & ((y > 3) | (x < 0))))
  
  See Also
  ========
  
  piecewise_fold
  piecewise_exclusive
  ITE
docstr: Return the indefinite integral of the
  Piecewise such that subsequent substitution of x with a
  value will give the value of the integral (not including
  the constant of integration) up to that point. To only
  integrate the individual parts of Piecewise, use the
  ``piecewise_integrate`` method.
  
  Examples
  ========
  
  >>> from sympy import Piecewise
  >>> from sympy.abc import x
  >>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
  >>> p.integrate(x)
  Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
  >>> p.piecewise_integrate(x)
  Piecewise((0, x < 0), (x, x < 1), (2*x, True))
  
  See Also
  ========
  Piecewise.piecewise_integrate
docstr_tok: ["Return","the","indefinite","integral","of","the","Piecewise","such","that","subsequent","substitution","of","x","with","a","value","will","give","the","value","of","the","integral","(","not","including","the","constant","of","integration",")","up","to","that","point",".","To","only","integrate","the","individual","parts","of","Piecewise",",","use","the","``","piecewise_integrate","``","method",".","Examples","========",">",">",">","from","sympy","import","Piecewise",">",">",">","from","sympy.abc","import","x",">",">",">","p","=","Piecewise","(","(","0",",","x","<","0",")",",","(","1",",","x","<","1",")",",","(","2",",","True",")",")",">",">",">","p.integrate","(","x",")","Piecewise","(","(","0",",","x","<","0",")",",","(","x",",","x","<","1",")",",","(","2","*","x","-","1",",","True",")",")",">",">",">","p.piecewise_integrate","(","x",")","Piecewise","(","(","0",",","x","<","0",")",",","(","x",",","x","<","1",")",",","(","2","*","x",",","True",")",")","See","Also","========","Piecewise.piecewise_integrate"]
code: def _eval_integral(self, x, _first=True, **kwargs):
      """Return the indefinite integral of the
      Piecewise such that subsequent substitution of x with a
      value will give the value of the integral (not including
      the constant of integration) up to that point. To only
      integrate the individual parts of Piecewise, use the
      ``piecewise_integrate`` method.
  
      Examples
      ========
  
      >>> from sympy import Piecewise
      >>> from sympy.abc import x
      >>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
      >>> p.integrate(x)
      Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
      >>> p.piecewise_integrate(x)
      Piecewise((0, x < 0), (x, x < 1), (2*x, True))
  
      See Also
      ========
      Piecewise.piecewise_integrate
      """
      from sympy.integrals.integrals import integrate
  
      if _first:
  
          def handler(ipw):
              if isinstance(ipw, self.func):
                  return ipw._eval_integral(x, _first=False, **kwargs)
              else:
                  return ipw.integrate(x, **kwargs)
  
          irv = self._handle_irel(x, handler)
          if irv is not None:
              return irv
  
      # handle a Piecewise from -oo to oo with and no x-independent relationals
      # -----------------------------------------------------------------------
      ok, abei = self._intervals(x)
      if not ok:
          from sympy.integrals.integrals import Integral
  
          return Integral(self, x)  # unevaluated
  
      pieces = [(a, b) for a, b, _, _ in abei]
      oo = S.Infinity
      done = [(-oo, oo, -1)]
      for k, p in enumerate(pieces):
          if p == (-oo, oo):
              # all undone intervals will get this key
              for j, (a, b, i) in enumerate(done):
                  if i == -1:
                      done[j] = a, b, k
              break  # nothing else to consider
          N = len(done) - 1
          for j, (a, b, i) in enumerate(reversed(done)):
              if i == -1:
                  j = N - j
                  done[j : j + 1] = _clip(p, (a, b), k)
      done = [(a, b, i) for a, b, i in done if a != b]
  
      # append an arg if there is a hole so a reference to
      # argument -1 will give Undefined
      if any(i == -1 for (a, b, i) in done):
          abei.append((-oo, oo, Undefined, -1))
  
      # return the sum of the intervals
      args = []
      sum = None
      for a, b, i in done:
          anti = integrate(abei[i][-2], x, **kwargs)
          if sum is None:
              sum = anti
          else:
              sum = sum.subs(x, a)
              e = anti._eval_interval(x, a, x)
              if sum.has(*_illegal) or e.has(*_illegal):
                  sum = anti
              else:
                  sum += e
          # see if we know whether b is contained in original
          # condition
          if b is S.Infinity:
              cond = True
          elif self.args[abei[i][-1]].cond.subs(x, b) == False:
              cond = x < b
          else:
              cond = x <= b
          args.append((sum, cond))
      return Piecewise(*args)
  
imports: from sympy.core import S, Function, diff, Tuple, Dummy, Mul
  from sympy.core.basic import Basic, as_Basic
  from sympy.core.numbers import Rational, NumberSymbol, _illegal
  from sympy.core.parameters import global_parameters
  from sympy.core.relational import Lt, Gt, Eq, Ne, Relational, _canonical, _canonical_coeff
  from sympy.core.sorting import ordered
  from sympy.functions.elementary.miscellaneous import Max, Min
  from sympy.logic.boolalg import And, Boolean, distribute_and_over_or, Not, true, false, Or, ITE, simplify_logic, to_cnf, distribute_or_over_and
  from sympy.utilities.iterables import uniq, sift, common_prefix
  from sympy.utilities.misc import filldedent, func_name
  from itertools import product
label_desc: Use image node_id 13 for calling the Piecewise obj's underlying member method code with example usage: obj._eval_integral(x, _first) and returns: Piecewise, Integral, irv, ipw, ipw