# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT

""" This module provides access to the mathematical functions
defined by the C standard. """

__doc__ = """This module provides access to the mathematical functions
defined by the C standard."""
__file__ = '/home/shared/src/ide-arm64/build-files/build-temp/runtimes-release/__os__/linux-arm64/runtime-python3.13/lib/python3.13/lib-dynload/math.cpython-313-aarch64-linux-gnu.so'
__loader__ = None
__name__ = 'math'
__package__ = ''
__spec__ = None

def acos(x):
  """ Return the arc cosine (measured in radians) of x.
  
  The result is between 0 and pi. """
  pass

def acosh(x):
  """ Return the inverse hyperbolic cosine of x. """
  pass

def asin(x):
  """ Return the arc sine (measured in radians) of x.
  
  The result is between -pi/2 and pi/2. """
  pass

def asinh(x):
  """ Return the inverse hyperbolic sine of x. """
  pass

def atan(x):
  """ Return the arc tangent (measured in radians) of x.
  
  The result is between -pi/2 and pi/2. """
  pass

def atan2(y, x):
  """ Return the arc tangent (measured in radians) of y/x.
  
  Unlike atan(y/x), the signs of both x and y are considered. """
  pass

def atanh(x):
  """ Return the inverse hyperbolic tangent of x. """
  pass

def cbrt(x):
  """ Return the cube root of x. """
  pass

def ceil(x):
  """ Return the ceiling of x as an Integral.
  
  This is the smallest integer >= x. """
  pass

def comb(n, k):
  """ Number of ways to choose k items from n items without repetition and without order.
  
  Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates
  to zero when k > n.
  
  Also called the binomial coefficient because it is equivalent
  to the coefficient of k-th term in polynomial expansion of the
  expression (1 + x)**n.
  
  Raises TypeError if either of the arguments are not integers.
  Raises ValueError if either of the arguments are negative. """
  pass

def copysign(x, y):
  """ Return a float with the magnitude (absolute value) of x but the sign of y.
  
  On platforms that support signed zeros, copysign(1.0, -0.0)
  returns -1.0.
   """
  pass

def cos(x):
  """ Return the cosine of x (measured in radians). """
  pass

def cosh(x):
  """ Return the hyperbolic cosine of x. """
  pass

def degrees(x):
  """ Convert angle x from radians to degrees. """
  pass

def dist(p, q):
  """ Return the Euclidean distance between two points p and q.
  
  The points should be specified as sequences (or iterables) of
  coordinates.  Both inputs must have the same dimension.
  
  Roughly equivalent to:
      sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) """
  pass

e = 2.718281828459045

def erf(x):
  """ Error function at x. """
  pass

def erfc(x):
  """ Complementary error function at x. """
  pass

def exp(x):
  """ Return e raised to the power of x. """
  pass

def exp2(x):
  """ Return 2 raised to the power of x. """
  pass

def expm1(x):
  """ Return exp(x)-1.
  
  This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. """
  pass

def fabs(x):
  """ Return the absolute value of the float x. """
  pass

def factorial(n):
  """ Find n!.
  
  Raise a ValueError if x is negative or non-integral. """
  pass

def floor(x):
  """ Return the floor of x as an Integral.
  
  This is the largest integer <= x. """
  pass

def fma(x, y, z):
  """ Fused multiply-add operation.
  
  Compute (x * y) + z with a single round. """
  pass

def fmod(x, y):
  """ Return fmod(x, y), according to platform C.
  
  x % y may differ. """
  pass

def frexp(x):
  """ Return the mantissa and exponent of x, as pair (m, e).
  
  m is a float and e is an int, such that x = m * 2.**e.
  If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0. """
  pass

def fsum(seq):
  """ Return an accurate floating-point sum of values in the iterable seq.
  
  Assumes IEEE-754 floating-point arithmetic. """
  pass

def gamma(x):
  """ Gamma function at x. """
  pass

def gcd(*integers):
  """ Greatest Common Divisor. """
  pass

def hypot(*coordinates):
  """ hypot(*coordinates) -> value
  
  Multidimensional Euclidean distance from the origin to a point.
  
  Roughly equivalent to:
      sqrt(sum(x**2 for x in coordinates))
  
  For a two dimensional point (x, y), gives the hypotenuse
  using the Pythagorean theorem:  sqrt(x*x + y*y).
  
  For example, the hypotenuse of a 3/4/5 right triangle is:
  
      >>> hypot(3.0, 4.0)
      5.0
   """
  return None

inf = inf

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
  """ Determine whether two floating-point numbers are close in value.
  
    rel_tol
      maximum difference for being considered "close", relative to the
      magnitude of the input values
    abs_tol
      maximum difference for being considered "close", regardless of the
      magnitude of the input values
  
  Return True if a is close in value to b, and False otherwise.
  
  For the values to be considered close, the difference between them
  must be smaller than at least one of the tolerances.
  
  -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That
  is, NaN is not close to anything, even itself.  inf and -inf are
  only close to themselves. """
  pass

def isfinite(x):
  """ Return True if x is neither an infinity nor a NaN, and False otherwise. """
  pass

def isinf(x):
  """ Return True if x is a positive or negative infinity, and False otherwise. """
  pass

def isnan(x):
  """ Return True if x is a NaN (not a number), and False otherwise. """
  pass

def isqrt(n):
  """ Return the integer part of the square root of the input. """
  pass

def lcm(*integers):
  """ Least Common Multiple. """
  pass

def ldexp(x, i):
  """ Return x * (2**i).
  
  This is essentially the inverse of frexp(). """
  pass

def lgamma(x):
  """ Natural logarithm of absolute value of Gamma function at x. """
  pass

def log():
  """ log(x, [base=math.e])
  Return the logarithm of x to the given base.
  
  If the base is not specified, returns the natural logarithm (base e) of x. """
  pass

def log10(x):
  """ Return the base 10 logarithm of x. """
  pass

def log1p(x):
  """ Return the natural logarithm of 1+x (base e).
  
  The result is computed in a way which is accurate for x near zero. """
  pass

def log2(x):
  """ Return the base 2 logarithm of x. """
  pass

def modf(x):
  """ Return the fractional and integer parts of x.
  
  Both results carry the sign of x and are floats. """
  pass

nan = nan

def nextafter(x, y, steps=None):
  """ Return the floating-point value the given number of steps after x towards y.
  
  If steps is not specified or is None, it defaults to 1.
  
  Raises a TypeError, if x or y is not a double, or if steps is not an integer.
  Raises ValueError if steps is negative. """
  pass

def perm(n, k=None):
  """ Number of ways to choose k items from n items without repetition and with order.
  
  Evaluates to n! / (n - k)! when k <= n and evaluates
  to zero when k > n.
  
  If k is not specified or is None, then k defaults to n
  and the function returns n!.
  
  Raises TypeError if either of the arguments are not integers.
  Raises ValueError if either of the arguments are negative. """
  pass

pi = 3.141592653589793

def pow(x, y):
  """ Return x**y (x to the power of y). """
  pass

def prod(iterable, start=1):
  """ Calculate the product of all the elements in the input iterable.
  
  The default start value for the product is 1.
  
  When the iterable is empty, return the start value.  This function is
  intended specifically for use with numeric values and may reject
  non-numeric types. """
  pass

def radians(x):
  """ Convert angle x from degrees to radians. """
  pass

def remainder(x, y):
  """ Difference between x and the closest integer multiple of y.
  
  Return x - n*y where n*y is the closest integer multiple of y.
  In the case where x is exactly halfway between two multiples of
  y, the nearest even value of n is used. The result is always exact. """
  pass

def sin(x):
  """ Return the sine of x (measured in radians). """
  pass

def sinh(x):
  """ Return the hyperbolic sine of x. """
  pass

def sqrt(x):
  """ Return the square root of x. """
  pass

def sumprod(p, q):
  """ Return the sum of products of values from two iterables p and q.
  
  Roughly equivalent to:
  
      sum(itertools.starmap(operator.mul, zip(p, q, strict=True)))
  
  For float and mixed int/float inputs, the intermediate products
  and sums are computed with extended precision. """
  pass

def tan(x):
  """ Return the tangent of x (measured in radians). """
  pass

def tanh(x):
  """ Return the hyperbolic tangent of x. """
  pass

tau = 6.283185307179586

def trunc(x):
  """ Truncates the Real x to the nearest Integral toward 0.
  
  Uses the __trunc__ magic method. """
  pass

def ulp(x):
  """ Return the value of the least significant bit of the float x. """
  pass