Package pygeodesy :: Module fmath
[frames] | no frames]

Module fmath

Precision floating point functions, utilities and constants.


Version: 20.10.11

Classes
  Fsum
Precision summation similar to standard Python function math.fsum.
  Fdot
Precision dot product.
  Fhorner
Precision polynomial evaluation using the Horner form.
  Fpolynomial
Precision polynomial evaluation.
Functions
 
hypot(x, y)
Return the Euclidean distance, sqrt(x*x + y*y).
 
cbrt(x)
Compute the cubic root x**(1/3).
 
cbrt2(x)
Compute the cubic root squared x**(2/3).
 
euclid(x, y)
Appoximate the norm sqrt(x**2 + y**2) by max(abs(x), abs(y)) + min(abs(x), abs(y)) * 0.4142....
 
euclid_(*xs)
Appoximate the norm sqrt(sum(x**2 for x in xs)) by cascaded euclid.
 
favg(v1, v2, f=0.5)
Return the average of two values.
 
fdot(a, *b)
Return the precision dot product sum(a[i] * b[i] for i=0..len(a)).
 
fdot3(a, b, c, start=0)
Return the precision dot product start + sum(a[i] * b[i] * c[i] for i=0..len(a)).
 
fhorner(x, *cs)
Evaluate the polynomial sum(cs[i] * x**i for i=0..len(cs)) using the Horner form.
 
fidw(xs, ds, beta=2)
Interpolate using using Inverse Distance Weighting (IDW).
 
fmean(xs)
Compute the accurate mean sum(xs[i] for i=0..len(xs)) / len(xs).
 
fpolynomial(x, *cs)
Evaluate the polynomial sum(cs[i] * x**i for i=0..len(cs)).
 
fpowers(x, n, alts=0)
Return a series of powers [x**i for i=1..n].
 
fprod(iterable, start=1.0)
Iterable product, like math.prod or numpy.prod.
 
frange(start, number, step=1)
Generate a range of floats.
value
freduce(function, sequence, initial=...)
Apply a function of two arguments cumulatively to the items of a sequence, from left to right, so as to reduce the sequence to a single value.
 
fsum_(*xs)
Precision summation of the positional argument vulues.
 
fsum(iterable)
Return an accurate floating point sum of values in the iterable.
 
hypot_(*xs)
Compute the norm sqrt(sum(x**2 for x in xs)).
 
hypot1(x)
Compute the norm sqrt(1 + x**2).
 
hypot2(x, y)
Compute the squared norm x**2 + y**2.
 
hypot2_(*xs)
Compute the squared norm sum(x**2 for x in xs).
 
sqrt3(x)
Compute the square root, cubed sqrt(x)**3 or sqrt(x**3).
Variables
  __all__ = _ALL_LAZY.fmath
Function Details

cbrt (x)

 

Compute the cubic root x**(1/3).

Arguments:
  • x - Value (scalar).
Returns:
Cubic root (float).

See Also: Functions cbrt2 and sqrt3.

cbrt2 (x)

 

Compute the cubic root squared x**(2/3).

Arguments:
  • x - Value (scalar).
Returns:
Cubic root squared (float).

See Also: Functions cbrt and sqrt3.

euclid (x, y)

 

Appoximate the norm sqrt(x**2 + y**2) by max(abs(x), abs(y)) + min(abs(x), abs(y)) * 0.4142....

Arguments:
  • x - X component (scalar).
  • y - Y component (scalar).
Returns:
Appoximate norm (float).

See Also: Function euclid_.

euclid_ (*xs)

 

Appoximate the norm sqrt(sum(x**2 for x in xs)) by cascaded euclid.

Arguments:
  • xs - X arguments, positional (scalar[]).
Returns:
Appoximate norm (float).

See Also: Function euclid.

favg (v1, v2, f=0.5)

 

Return the average of two values.

Arguments:
  • v1 - One value (scalar).
  • v2 - Other value (scalar).
  • f - Optional fraction (float).
Returns:
v1 + f * (v2 - v1) (float).

fdot (a, *b)

 

Return the precision dot product sum(a[i] * b[i] for i=0..len(a)).

Arguments:
  • a - List, sequence, tuple, etc. (scalars).
  • b - All positional arguments (scalars).
Returns:
Dot product (float).
Raises:

See Also: Class Fdot.

fdot3 (a, b, c, start=0)

 

Return the precision dot product start + sum(a[i] * b[i] * c[i] for i=0..len(a)).

Arguments:
  • a - List, sequence, tuple, etc. (scalar[]).
  • b - List, sequence, tuple, etc. (scalar[]).
  • c - List, sequence, tuple, etc. (scalar[]).
  • start - Optional bias (scalar).
Returns:
Dot product (float).
Raises:
  • LenError - Unequal len(a), len(b) and/or len(c).
  • OverflowError - Partial 2sum overflow.

fhorner (x, *cs)

 

Evaluate the polynomial sum(cs[i] * x**i for i=0..len(cs)) using the Horner form.

Arguments:
  • x - Polynomial argument (scalar).
  • cs - Polynomial coeffients (scalar[]).
Returns:
Horner value (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • TypeError - Non-scalar x.
  • ValueError - No cs coefficients or x is not finite.

See Also: Function fpolynomial and class Fhorner.

fidw (xs, ds, beta=2)

 

Interpolate using using Inverse Distance Weighting (IDW).

Arguments:
  • xs - Known values (scalar[]).
  • ds - Non-negative distances (scalar[]).
  • beta - Inverse distance power (int, 0, 1, 2, or 3).
Returns:
Interpolated value x (float).
Raises:
  • LenError - Unequal or zero len(ds) and len(xs).
  • ValueError - Invalid beta, negative ds value, weighted ds below EPS.

Note: Using beta=0 returns the mean of xs.

fmean (xs)

 

Compute the accurate mean sum(xs[i] for i=0..len(xs)) / len(xs).

Arguments:
  • xs - Values (scalars).
Returns:
Mean value (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • ValueError - No xs values.

fpolynomial (x, *cs)

 

Evaluate the polynomial sum(cs[i] * x**i for i=0..len(cs)).

Arguments:
  • x - Polynomial argument (scalar).
  • cs - Polynomial coeffients (scalar[]).
Returns:
Polynomial value (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • TypeError - Non-scalar x.
  • ValueError - No cs coefficients or x is not finite.

See Also: Function fhorner and class Fpolynomial.

fpowers (x, n, alts=0)

 

Return a series of powers [x**i for i=1..n].

Arguments:
  • x - Value (scalar).
  • n - Highest exponent (int).
  • alts - Only alternating powers, starting with this exponent (int).
Returns:
Powers of x (float[]).
Raises:
  • TypeError - Non-scalar x or n not int.
  • ValueError - Non-finite x or non-positive n.

fprod (iterable, start=1.0)

 

Iterable product, like math.prod or numpy.prod.

Arguments:
  • iterable - Terms to be multiplied (scalar[]).
  • start - Initial term, also the value returned for an empty iterable (scalar).
Returns:
The product (float).

See Also: NumPy.prod.

frange (start, number, step=1)

 

Generate a range of floats.

Arguments:
  • start - First value (float).
  • number - The number of floats to generate (int).
  • step - Increment value (float).
Returns:
A generator (floats).

See Also: NumPy.prod.

freduce (function, sequence, initial=...)

 

Apply a function of two arguments cumulatively to the items of a sequence, from left to right, so as to reduce the sequence to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). If initial is present, it is placed before the items of the sequence in the calculation, and serves as a default when the sequence is empty.

Returns: value

fsum_ (*xs)

 

Precision summation of the positional argument vulues.

Arguments:
  • xs - Values to be added (scalar[]).
Returns:
Accurate fsum (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • TypeError - Non-scalar xs value.
  • ValueError - Invalid or non-finite xs value.

fsum (iterable)

 

Return an accurate floating point sum of values in the iterable. Assumes IEEE-754 floating point arithmetic.

hypot_ (*xs)

 

Compute the norm sqrt(sum(x**2 for x in xs)).

Arguments:
  • xs - X arguments, positional (scalar[]).
Returns:
Norm (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • ValueError - Invalid or no xs value.

See Also: Similar to Python 3.8+ math.hypot, but handling of exceptions, nan and infinite values is different.

Note: The Python 3.8+ math.dist Euclidian distance between 2 n-dimensional points p1 and p2 can be computed as hypot_(*((c1 - c2) for c1, c2 in zip(p1, p2))), provided p1 and p2 have the same, non-zero length n.

hypot1 (x)

 

Compute the norm sqrt(1 + x**2).

Arguments:
  • x - Argument (scalar).
Returns:
Norm (float).

hypot2 (x, y)

 

Compute the squared norm x**2 + y**2.

Arguments:
  • x - Argument (scalar).
  • y - Argument (scalar).
Returns:
x**2 + y**2 (float).

hypot2_ (*xs)

 

Compute the squared norm sum(x**2 for x in xs).

Arguments:
  • xs - X arguments, positional (scalar[]).
Returns:
Squared norm (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • ValueError - Invalid or no xs value.

See Also: Function hypot_.

sqrt3 (x)

 

Compute the square root, cubed sqrt(x)**3 or sqrt(x**3).

Arguments:
  • x - Value (scalar).
Returns:
Cubed square root (float).
Raises:
  • ValueError - Negative x.

See Also: Functions cbrt and cbrt2.