radis.misc.arrays module

Description

Functions to deal with numpy arrays:

• norm()

• norm_on()

• scale_to()

• array_allclose()

• nantrapz()

• arange_len()

• calc_diff()

• find_nearest()

• find_first()

• autoturn()

• centered_diff()

• evenly_distributed()

• anynan()

• first_nonnan_index()

• last_nonan_index()

• is_sorted()

• is_sorted_backward()

• bining()

• count_nans()

• logspace()

• numpy_add_at()

anynan(a)

Returns whether a has at least one nan

Fastest implementation for arrays with >10^4 elements https://stackoverflow.com/a/45011547/5622825

anynan_vaex(a)

arange_len(wmin, wmax, wstep) → int

Returns len of a numpy.arange() (wmin, max, wstep) array, accounting for floating point errors

Note: numpy.arange() is useful to maintain the input wstep. If you don’t have this requirement, you better use numpy.linspace() directly.

array_allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=True)

Returns whether a and b are all close (element wise). If not the same size, returns False (instead of crashing like the numpy version). Cf numpy.allclose docs for more information.

Parameters:

• a, b (arrays)

• rtol (float)

• atol (float)

• equal_nan (bool) – whether to consider NaN’s as equal. Contrary to the numpy version this one is set to True by default

autoturn(data, key=-1)

Turns array data. key value:

• 0 don’t transpose

• 1 : transpose

• -1 : auto : make sure the vectors are along the longest dimension

bining(I, ymin=None, ymax=None, axis=1)

Averages a I multi-dimensional array (typically an image) along the y axis bining(I) corresponds to I.mean(axis=1) NaN are not taken into account.

Parameters:

• I (numpy array) – intensity

• ymin (int [0-I.shape[1]]) – If None, 0 is used. Default None.

• ymax (int [0-I.shape[1]]) – If None, I.shape[1] is used. Default None.

• axis (int) – Default 1

boolean_array_from_ranges(ranges, n)

return a boolean array of length n where (L[i][0], L[i][1]) give the ranges set to True

Examples

L = np.array([[2,4], [5,6], [7,8]])
boolean_array_from_coordinates(*L.T, 8)
>>> np.array([0, 0, 1, 1, 0, 1, 0, 1], dtype=bool)

calc_diff(t1, v1, t2, v2)

Subtract two vectors that may have slightly offset abscissa interpolating the correct values.

Parameters:

• t1, v1 (array_like) – first vector and its abscissa

• t2, v2 (array_like) – second vector and its abscissa

Returns:

tdiff, vdiff – subtracted vector and its abscissa

Return type:

array_like

centered_diff(w)

Return w[i+1]-w[i-1]/2, same size as w.

Similar to numpy.diff(), but does not change the array size.

count_nans(a)

NaN are good but only in India.

evenly_distributed(w, atolerance=1e-05)

Make sure array w is evenly distributed.

Parameters:

• w (numpy array) – array to test

• atolerance (float) – absolute tolerance

Returns:

out – True or False if w is evenly distributed.

Return type:

bool

See also

evenly_distributed_fast()

evenly_distributed_fast(w, rtolerance=1e-05)

Make sure array w is evenly distributed, by looking only at the first and last steps. i.e:

w[-1] - w[-2] == w[1] - w[0]

Parameters:

• w (numpy array) – array to test

• rtolerance (float) – relative tolerance

Returns:

out – True or False if w is evenly distributed.

Return type:

bool

See also

evenly_distributed()

find_first(arr, threshold)

Return the index of the first element of the array arr whose value is more than the threshold.

find_nearest(array, searched, return_bool=False)

Return the closest elements in array for each element in ‘searched’ array. In case of multiple elements in array having equal difference with searched element, one with least index is returned. Also returns a boolean array with indices of elements occurring in output list set to true.

Examples

from numpy import array
find_nearest(array([1,2,3,4]), array([2.1,2]), True)

>>> (array([2, 2]), array([False, True, False, False]))

find_nearest(np.array([1,2,3,4]), np.array([2.6,2]), True)

>>> (array([3, 2]), array([False,  True,  True, False]))

find_nearest(np.array([1, 3]), np.array([2]))

>>> array([1])

find_nearest(np.array([3, 1]), np.array([2]))

>>> array([3])

first_nonnan_index(a)

Returns index of first non-nan value in a

Returns None is all values are nan

See also

last_nonnan_index()

is_sorted(a)

Returns whether a is sorted in ascending order.

From B.M. answer on StackOverflow: https://stackoverflow.com/a/47004533/5622825

See also

is_sorted_backward()

is_sorted_backward(a)

Returns whether a is sorted in descending order.

See also

is_sorted()

last_nonnan_index(a)

Returns index of first non-nan value in a

Returns None is all values are nan

See also

first_nonnan_index()

logspace(xmin, xmax, npoints)

Returns points from xmin to xmax regularly distributed on a logarithm space.

Numpy’s numpy.logspace() does the same from 10**xmin to 10**xmax

nantrapz(I, w, dx=1.0, axis=-1)

Returns trapezoid() (I, w) discarding nan.

non_zero_ranges_in_array(b)

return a list of coordinates corresponding to non-zero values in boolean array b

Parameters:

b (boolean array)

Examples

b = np.array([0,0,1,1,0,1,0,1], dtype=bool)
non_zero_ranges_in_array(b)
>> ([2, 5, 7],
    [4, 6, 8])

non_zero_values_around(a, n)

return a boolean array of same size as a where each position i is True if there are non-zero points less than n index position away from a[i], and False if all points in a are 0 n index position away from a[i]

norm(a, normby=None, how='max')

Normalize a numpy array with its maximum. Or normalize it with another vector. Works if array contains nans.

Parameters:

normby (array, or None) – if array, norm with this other array’s maximum. If None, normalize with its maximum.

norm_on(a, w, wmin=None, wmax=None, how='max')

Normalize a on a specific range of w

Parameters:

• a (array) – array

• w (array) – x-axis array

Other Parameters:

• wmin, wmax (float) – crop range

• how (‘mean’, ‘max’) – how to normalize

Returns:

a_norm – normalized array

Return type:

array

numpy_add_at(LDM, k, l, m, I)

Add the linestrengths on the LDM grid.

Uses the numpy implementation of at(), which add arguments element-wise.

Parameters:

• LDM (ndarray) – LDM grid

• k, l, m (array) – index

• I (array) – intensity to add

Returns:

add – linestrengths distributed over the LDM grid

Return type:

ndarray

Notes

Cython version implemented in https://github.com/radis/radis/pull/234

See also

numpy.add.at()

scale_to(a, b, k=1)

Scale function a to k*b.

sparse_add_at(ki0, Iv0, Iv1, weight, max_range, truncation_pts)

Returns (start, stop) of non-zero ranges, and intensity I (length truncation_pts) for all line intensities Iv0 and Iv1 at position ki0 and ki0+1 with weights weight

Warning

ki0 must be sorted.