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 Piecewise with each expression being
  replaced with its antiderivative. To obtain a continuous
  antiderivative, use the :func:`~.integrate` function or method.
  
  Examples
  ========
  
  >>> from sympy import Piecewise
  >>> from sympy.abc import x
  >>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
  >>> p.piecewise_integrate(x)
  Piecewise((0, x < 0), (x, x < 1), (2*x, True))
  
  Note that this does not give a continuous function, e.g.
  at x = 1 the 3rd condition applies and the antiderivative
  there is 2*x so the value of the antiderivative is 2:
  
  >>> anti = _
  >>> anti.subs(x, 1)
  2
  
  The continuous derivative accounts for the integral *up to*
  the point of interest, however:
  
  >>> p.integrate(x)
  Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
  >>> _.subs(x, 1)
  1
  
  See Also
  ========
  Piecewise._eval_integral
docstr_tok: ["Return","the","Piecewise","with","each","expression","being","replaced","with","its","antiderivative",".","To","obtain","a","continuous","antiderivative",",","use","the",":","func",":","`","~.integrate","`","function","or","method",".","Examples","========",">",">",">","from","sympy","import","Piecewise",">",">",">","from","sympy.abc","import","x",">",">",">","p","=","Piecewise","(","(","0",",","x","<","0",")",",","(","1",",","x","<","1",")",",","(","2",",","True",")",")",">",">",">","p.piecewise_integrate","(","x",")","Piecewise","(","(","0",",","x","<","0",")",",","(","x",",","x","<","1",")",",","(","2","*","x",",","True",")",")","Note","that","this","does","not","give","a","continuous","function",",","e.g",".","at","x","=","1","the","3rd","condition","applies","and","the","antiderivative","there","is","2","*","x","so","the","value","of","the","antiderivative","is","2",":",">",">",">","anti","=","_",">",">",">","anti.subs","(","x",",","1",")","2","The","continuous","derivative","accounts","for","the","integral","*","up","to","*","the","point","of","interest",",","however",":",">",">",">","p.integrate","(","x",")","Piecewise","(","(","0",",","x","<","0",")",",","(","x",",","x","<","1",")",",","(","2","*","x","-","1",",","True",")",")",">",">",">","_.subs","(","x",",","1",")","1","See","Also","========","Piecewise._eval_integral"]
code: def piecewise_integrate(self, x, **kwargs):
      """Return the Piecewise with each expression being
      replaced with its antiderivative. To obtain a continuous
      antiderivative, use the :func:`~.integrate` function or method.
  
      Examples
      ========
  
      >>> from sympy import Piecewise
      >>> from sympy.abc import x
      >>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
      >>> p.piecewise_integrate(x)
      Piecewise((0, x < 0), (x, x < 1), (2*x, True))
  
      Note that this does not give a continuous function, e.g.
      at x = 1 the 3rd condition applies and the antiderivative
      there is 2*x so the value of the antiderivative is 2:
  
      >>> anti = _
      >>> anti.subs(x, 1)
      2
  
      The continuous derivative accounts for the integral *up to*
      the point of interest, however:
  
      >>> p.integrate(x)
      Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
      >>> _.subs(x, 1)
      1
  
      See Also
      ========
      Piecewise._eval_integral
      """
      from sympy.integrals import integrate
  
      return self.func(
          *[(integrate(e, x, **kwargs), c) for e, c in self.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 11 for calling the Piecewise obj's underlying member method code with example usage: obj.piecewise_integrate(x) and returns: self