class_docstr: Context for multiprecision arithmetic with a global precision.
class_docstr_tok: ["Context","for","multiprecision","arithmetic","with","a","global","precision","."]
docstr: Multiplies the numbers *x* and *y*, giving a floating-point result,
  optionally using a custom precision and rounding mode.
  
  See the documentation of :func:`~mpmath.fadd` for a detailed description
  of how to specify precision and rounding.
  
  **Examples**
  
  The result is an mpmath number::
  
      >>> from mpmath import *
      >>> mp.dps = 15; mp.pretty = False
      >>> fmul(2, 5.0)
      mpf('10.0')
      >>> fmul(0.5j, 0.5)
      mpc(real='0.0', imag='0.25')
  
  Avoiding roundoff::
  
      >>> x, y = 10**10+1, 10**15+1
      >>> print(x*y)
      10000000001000010000000001
      >>> print(mpf(x) * mpf(y))
      1.0000000001e+25
      >>> print(int(mpf(x) * mpf(y)))
      10000000001000011026399232
      >>> print(int(fmul(x, y)))
      10000000001000011026399232
      >>> print(int(fmul(x, y, dps=25)))
      10000000001000010000000001
      >>> print(int(fmul(x, y, exact=True)))
      10000000001000010000000001
  
  Exact multiplication with complex numbers can be inefficient and may
  be impossible to perform with large magnitude differences between
  real and imaginary parts::
  
      >>> x = 1+2j
      >>> y = mpc(2, '1e-100000000000000000000')
      >>> fmul(x, y)
      mpc(real='2.0', imag='4.0')
      >>> fmul(x, y, rounding='u')
      mpc(real='2.0', imag='4.0000000000000009')
      >>> fmul(x, y, exact=True)
      Traceback (most recent call last):
        ...
      OverflowError: the exact result does not fit in memory
docstr_tok: ["Multiplies","the","numbers","*","x","*","and","*","y","*",",","giving","a","floating-point","result",",","optionally","using","a","custom","precision","and","rounding","mode",".","See","the","documentation","of",":","func",":","`","~mpmath.fadd","`","for","a","detailed","description","of","how","to","specify","precision","and","rounding",".","*","*","Examples","*","*","The","result","is","an","mpmath","number",":",":",">",">",">","from","mpmath","import","*",">",">",">","mp.dps","=","15",";","mp.pretty","=","False",">",">",">","fmul","(","2",",","5.0",")","mpf","(","'10.0","'",")",">",">",">","fmul","(","0.5j",",","0.5",")","mpc","(","real=","'","0.0","'",",","imag=","'","0.25","'",")","Avoiding","roundoff",":",":",">",">",">","x",",","y","=","10","*","*","10+1",",","10","*","*","15+1",">",">",">","print","(","x","*","y",")","10000000001000010000000001",">",">",">","print","(","mpf","(","x",")","*","mpf","(","y",")",")","1.0000000001e+25",">",">",">","print","(","int","(","mpf","(","x",")","*","mpf","(","y",")",")",")","10000000001000011026399232",">",">",">","print","(","int","(","fmul","(","x",",","y",")",")",")","10000000001000011026399232",">",">",">","print","(","int","(","fmul","(","x",",","y",",","dps=25",")",")",")","10000000001000010000000001",">",">",">","print","(","int","(","fmul","(","x",",","y",",","exact=True",")",")",")","10000000001000010000000001","Exact","multiplication","with","complex","numbers","can","be","inefficient","and","may","be","impossible","to","perform","with","large","magnitude","differences","between","real","and","imaginary","parts",":",":",">",">",">","x","=","1+2j",">",">",">","y","=","mpc","(","2",",","'1e-100000000000000000000","'",")",">",">",">","fmul","(","x",",","y",")","mpc","(","real=","'","2.0","'",",","imag=","'","4.0","'",")",">",">",">","fmul","(","x",",","y",",","rounding=","'","u","'",")","mpc","(","real=","'","2.0","'",",","imag=","'","4.0000000000000009","'",")",">",">",">","fmul","(","x",",","y",",","exact=True",")","Traceback","(","most","recent","call","last",")",":","...","OverflowError",":","the","exact","result","does","not","fit","in","memory"]
code: def fmul(ctx, x, y, **kwargs):
      """
      Multiplies the numbers *x* and *y*, giving a floating-point result,
      optionally using a custom precision and rounding mode.
  
      See the documentation of :func:`~mpmath.fadd` for a detailed description
      of how to specify precision and rounding.
  
      **Examples**
  
      The result is an mpmath number::
  
          >>> from mpmath import *
          >>> mp.dps = 15; mp.pretty = False
          >>> fmul(2, 5.0)
          mpf('10.0')
          >>> fmul(0.5j, 0.5)
          mpc(real='0.0', imag='0.25')
  
      Avoiding roundoff::
  
          >>> x, y = 10**10+1, 10**15+1
          >>> print(x*y)
          10000000001000010000000001
          >>> print(mpf(x) * mpf(y))
          1.0000000001e+25
          >>> print(int(mpf(x) * mpf(y)))
          10000000001000011026399232
          >>> print(int(fmul(x, y)))
          10000000001000011026399232
          >>> print(int(fmul(x, y, dps=25)))
          10000000001000010000000001
          >>> print(int(fmul(x, y, exact=True)))
          10000000001000010000000001
  
      Exact multiplication with complex numbers can be inefficient and may
      be impossible to perform with large magnitude differences between
      real and imaginary parts::
  
          >>> x = 1+2j
          >>> y = mpc(2, '1e-100000000000000000000')
          >>> fmul(x, y)
          mpc(real='2.0', imag='4.0')
          >>> fmul(x, y, rounding='u')
          mpc(real='2.0', imag='4.0000000000000009')
          >>> fmul(x, y, exact=True)
          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_mul(x._mpf_, y._mpf_, prec, rounding)
                  )
              if hasattr(y, "_mpc_"):
                  return ctx.make_mpc(
                      mpc_mul_mpf(y._mpc_, x._mpf_, prec, rounding)
                  )
          if hasattr(x, "_mpc_"):
              if hasattr(y, "_mpf_"):
                  return ctx.make_mpc(
                      mpc_mul_mpf(x._mpc_, y._mpf_, prec, rounding)
                  )
              if hasattr(y, "_mpc_"):
                  return ctx.make_mpc(
                      mpc_mul(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 40 for calling the MPContext obj's underlying member method code with example usage: obj.fmul(ctx, x, y) and returns: ctx, ctx, ctx, ctx