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

Module fmath

Precision floating point functions, classes and utilities.


Version: 21.06.30

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
 
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.
 
facos1(x)
Fast approximation of acos1(x).
 
fasin1(x)
Fast approximation of asin1(x).
 
fatan(x)
Fast approximation of atan(x).
 
fatan1(x)
Fast approximation of atan(x) for 0 <= x <= 1, unchecked.
 
fatan2(y, x)
Fast approximation of atan2(y, x).
 
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).
 
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 all positional arguments.
 
fsum(iterable)
Return an accurate floating point sum of values in the iterable.
 
hypot(x, y)
Return the Euclidean distance, sqrt(x*x + y*y).
 
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).
 
norm2(x, y)
Normalize a 2-dimensional vector.
 
norm_(*xs)
Normalize all n-dimensional vector components.
 
sqrt0(x)
Compute the square root iff x > EPS0**2.
 
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.

facos1 (x)

 

Fast approximation of acos1(x).

See Also: ShaderFastLibs.h.

fasin1 (x)

 

Fast approximation of asin1(x).

See Also: facos1.

fatan1 (x)

 

Fast approximation of atan(x) for 0 <= x <= 1, unchecked.

See Also: ShaderFastLibs.h and Efficient approximations for the arctangent function, IEEE Signal Processing Magazine, 111, May 2006.

fatan2 (y, x)

 

Fast approximation of atan2(y, x).

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.

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 (floats or ints).
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 all positional arguments.

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+ n-dimension math.hypot, but handling of exceptions, nan and infinite values is different.

Note: The Python 3.8+ Euclidian distance math.dist 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_.

norm2 (x, y)

 

Normalize a 2-dimensional vector.

Arguments:
  • x - X component (scalar).
  • y - Y component (scalar).
Returns:
2-Tuple (x, y), normalized.
Raises:
  • ValueError - Invalid x or y or zero norm.

norm_ (*xs)

 

Normalize all n-dimensional vector components.

Arguments:
  • xs - The component (scalar[]).
Returns:
Yield each component, normalized.
Raises:
  • ValueError - Invalid or insufficent xs or zero norm.

sqrt0 (x)

 

Compute the square root iff x > EPS0**2.

Arguments:
  • x - Value (scalar).
Returns:
Square root (float) or 0.0.

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.