class_docstr: Context for multiprecision arithmetic with a global precision.
class_docstr_tok: ["Context","for","multiprecision","arithmetic","with","a","global","precision","."]
docstr: Adds the numbers *x* and *y*, giving a floating-point result,
  optionally using a custom precision and rounding mode.
  
  The default precision is the working precision of the context.
  You can specify a custom precision in bits by passing the *prec* keyword
  argument, or by providing an equivalent decimal precision with the *dps*
  keyword argument. If the precision is set to ``+inf``, or if the flag
  *exact=True* is passed, an exact addition with no rounding is performed.
  
  When the precision is finite, the optional *rounding* keyword argument
  specifies the direction of rounding. Valid options are ``'n'`` for
  nearest (default), ``'f'`` for floor, ``'c'`` for ceiling, ``'d'``
  for down, ``'u'`` for up.
  
  **Examples**
  
  Using :func:`~mpmath.fadd` with precision and rounding control::
  
      >>> from mpmath import *
      >>> mp.dps = 15; mp.pretty = False
      >>> fadd(2, 1e-20)
      mpf('2.0')
      >>> fadd(2, 1e-20, rounding='u')
      mpf('2.0000000000000004')
      >>> nprint(fadd(2, 1e-20, prec=100), 25)
      2.00000000000000000001
      >>> nprint(fadd(2, 1e-20, dps=15), 25)
      2.0
      >>> nprint(fadd(2, 1e-20, dps=25), 25)
      2.00000000000000000001
      >>> nprint(fadd(2, 1e-20, exact=True), 25)
      2.00000000000000000001
  
  Exact addition avoids cancellation errors, enforcing familiar laws
  of numbers such as `x+y-x = y`, which don't hold in floating-point
  arithmetic with finite precision::
  
      >>> x, y = mpf(2), mpf('1e-1000')
      >>> print(x + y - x)
      0.0
      >>> print(fadd(x, y, prec=inf) - x)
      1.0e-1000
      >>> print(fadd(x, y, exact=True) - x)
      1.0e-1000
  
  Exact addition can be inefficient and may be impossible to perform
  with large magnitude differences::
  
      >>> fadd(1, '1e-100000000000000000000', prec=inf)
      Traceback (most recent call last):
        ...
      OverflowError: the exact result does not fit in memory
docstr_tok: ["Adds","the","numbers","*","x","*","and","*","y","*",",","giving","a","floating-point","result",",","optionally","using","a","custom","precision","and","rounding","mode",".","The","default","precision","is","the","working","precision","of","the","context",".","You","can","specify","a","custom","precision","in","bits","by","passing","the","*","prec","*","keyword","argument",",","or","by","providing","an","equivalent","decimal","precision","with","the","*","dps","*","keyword","argument",".","If","the","precision","is","set","to","``","+inf","``",",","or","if","the","flag","*","exact=True","*","is","passed",",","an","exact","addition","with","no","rounding","is","performed",".","When","the","precision","is","finite",",","the","optional","*","rounding","*","keyword","argument","specifies","the","direction","of","rounding",".","Valid","options","are","``","'n","'","``","for","nearest","(","default",")",",","``","'","f","'","``","for","floor",",","``","'","c","'","``","for","ceiling",",","``","'d","'","``","for","down",",","``","'","u","'","``","for","up",".","*","*","Examples","*","*","Using",":","func",":","`","~mpmath.fadd","`","with","precision","and","rounding","control",":",":",">",">",">","from","mpmath","import","*",">",">",">","mp.dps","=","15",";","mp.pretty","=","False",">",">",">","fadd","(","2",",","1e-20",")","mpf","(","'","2.0","'",")",">",">",">","fadd","(","2",",","1e-20",",","rounding=","'","u","'",")","mpf","(","'","2.0000000000000004","'",")",">",">",">","nprint","(","fadd","(","2",",","1e-20",",","prec=100",")",",","25",")","2.00000000000000000001",">",">",">","nprint","(","fadd","(","2",",","1e-20",",","dps=15",")",",","25",")","2.0",">",">",">","nprint","(","fadd","(","2",",","1e-20",",","dps=25",")",",","25",")","2.00000000000000000001",">",">",">","nprint","(","fadd","(","2",",","1e-20",",","exact=True",")",",","25",")","2.00000000000000000001","Exact","addition","avoids","cancellation","errors",",","enforcing","familiar","laws","of","numbers","such","as","`","x+y-x","=","y","`",",","which","do","n't","hold","in","floating-point","arithmetic","with","finite","precision",":",":",">",">",">","x",",","y","=","mpf","(","2",")",",","mpf","(","'1e-1000","'",")",">",">",">","print","(","x","+","y","-","x",")","0.0",">",">",">","print","(","fadd","(","x",",","y",",","prec=inf",")","-","x",")","1.0e-1000",">",">",">","print","(","fadd","(","x",",","y",",","exact=True",")","-","x",")","1.0e-1000","Exact","addition","can","be","inefficient","and","may","be","impossible","to","perform","with","large","magnitude","differences",":",":",">",">",">","fadd","(","1",",","'1e-100000000000000000000","'",",","prec=inf",")","Traceback","(","most","recent","call","last",")",":","...","OverflowError",":","the","exact","result","does","not","fit","in","memory"]
code: def fadd(ctx, x, y, **kwargs):
      """
      Adds the numbers *x* and *y*, giving a floating-point result,
      optionally using a custom precision and rounding mode.
  
      The default precision is the working precision of the context.
      You can specify a custom precision in bits by passing the *prec* keyword
      argument, or by providing an equivalent decimal precision with the *dps*
      keyword argument. If the precision is set to ``+inf``, or if the flag
      *exact=True* is passed, an exact addition with no rounding is performed.
  
      When the precision is finite, the optional *rounding* keyword argument
      specifies the direction of rounding. Valid options are ``'n'`` for
      nearest (default), ``'f'`` for floor, ``'c'`` for ceiling, ``'d'``
      for down, ``'u'`` for up.
  
      **Examples**
  
      Using :func:`~mpmath.fadd` with precision and rounding control::
  
          >>> from mpmath import *
          >>> mp.dps = 15; mp.pretty = False
          >>> fadd(2, 1e-20)
          mpf('2.0')
          >>> fadd(2, 1e-20, rounding='u')
          mpf('2.0000000000000004')
          >>> nprint(fadd(2, 1e-20, prec=100), 25)
          2.00000000000000000001
          >>> nprint(fadd(2, 1e-20, dps=15), 25)
          2.0
          >>> nprint(fadd(2, 1e-20, dps=25), 25)
          2.00000000000000000001
          >>> nprint(fadd(2, 1e-20, exact=True), 25)
          2.00000000000000000001
  
      Exact addition avoids cancellation errors, enforcing familiar laws
      of numbers such as `x+y-x = y`, which don't hold in floating-point
      arithmetic with finite precision::
  
          >>> x, y = mpf(2), mpf('1e-1000')
          >>> print(x + y - x)
          0.0
          >>> print(fadd(x, y, prec=inf) - x)
          1.0e-1000
          >>> print(fadd(x, y, exact=True) - x)
          1.0e-1000
  
      Exact addition can be inefficient and may be impossible to perform
      with large magnitude differences::
  
          >>> fadd(1, '1e-100000000000000000000', prec=inf)
          Traceback (most recent call last):
            ...
          OverflowError: the exact result does not fit in memory
  
      """
      prec, rounding = ctx._parse_prec(kwargs)
      x = ctx.convert(x)
      y = ctx.convert(y)
      try:
          if hasattr(x, "_mpf_"):
              if hasattr(y, "_mpf_"):
                  return ctx.make_mpf(
                      mpf_add(x._mpf_, y._mpf_, prec, rounding)
                  )
              if hasattr(y, "_mpc_"):
                  return ctx.make_mpc(
                      mpc_add_mpf(y._mpc_, x._mpf_, prec, rounding)
                  )
          if hasattr(x, "_mpc_"):
              if hasattr(y, "_mpf_"):
                  return ctx.make_mpc(
                      mpc_add_mpf(x._mpc_, y._mpf_, prec, rounding)
                  )
              if hasattr(y, "_mpc_"):
                  return ctx.make_mpc(
                      mpc_add(x._mpc_, y._mpc_, prec, rounding)
                  )
      except (ValueError, OverflowError):
          raise OverflowError(ctx._exact_overflow_msg)
      raise ValueError(
          "Arguments need to be mpf or mpc compatible numbers"
      )
  
imports: import functools
  import re
  from .ctx_base import StandardBaseContext
  from .libmp.backend import basestring, BACKEND
  from .None import libmp
  from .libmp import MPZ, MPZ_ZERO, MPZ_ONE, int_types, repr_dps, round_floor, round_ceiling, dps_to_prec, round_nearest, prec_to_dps, ComplexResult, to_pickable, from_pickable, normalize, from_int, from_float, from_str, to_int, to_float, to_str, from_rational, from_man_exp, fone, fzero, finf, fninf, fnan, mpf_abs, mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul, mpf_mul_int, mpf_div, mpf_rdiv_int, mpf_pow_int, mpf_mod, mpf_eq, mpf_cmp, mpf_lt, mpf_gt, mpf_le, mpf_ge, mpf_hash, mpf_rand, mpf_sum, bitcount, to_fixed, mpc_to_str, mpc_to_complex, mpc_hash, mpc_pos, mpc_is_nonzero, mpc_neg, mpc_conjugate, mpc_abs, mpc_add, mpc_add_mpf, mpc_sub, mpc_sub_mpf, mpc_mul, mpc_mul_mpf, mpc_mul_int, mpc_div, mpc_div_mpf, mpc_pow, mpc_pow_mpf, mpc_pow_int, mpc_mpf_div, mpf_pow, mpf_pi, mpf_degree, mpf_e, mpf_phi, mpf_ln2, mpf_ln10, mpf_euler, mpf_catalan, mpf_apery, mpf_khinchin, mpf_glaisher, mpf_twinprime, mpf_mertens, int_types
  from .None import function_docs
  from .None import rational
  from .ctx_mp_python import _mpf, _mpc, mpnumeric
label_desc: Use image node_id 38 for calling the MPContext obj's underlying member method code with example usage: obj.fadd(ctx, x, y) and returns: ctx, ctx, ctx, ctx