Numerics Module

nexus.numerics.least_squares(p, x, y, f)

nexus.numerics.absmin(p, x, y, f)

nexus.numerics.madmin(p, x, y, f)

nexus.numerics.curve_fit(x, y, f, p0, cost='least_squares', optimizer='fmin')

nexus.numerics.morse(p, r)

nexus.numerics.morse_re(p)

nexus.numerics.morse_a(p)

nexus.numerics.morse_De(p)

nexus.numerics.morse_Einf(p)

nexus.numerics.morse_width(p)

nexus.numerics.morse_depth(p)

nexus.numerics.morse_Ee(p)

nexus.numerics.morse_k(p)

nexus.numerics.morse_params(re, a, De, E_inf)

nexus.numerics.morse_reduced_mass(m1, m2=None)

nexus.numerics.morse_freq(p, m1, m2=None)

nexus.numerics.morse_w(p, m1, m2=None)

nexus.numerics.morse_wX(p, m1, m2=None)

nexus.numerics.morse_E0(p, m1, m2=None)

nexus.numerics.morse_En(p, n, m1, m2=None)

nexus.numerics.morse_zero_point(p, m1, m2=None)

nexus.numerics.morse_harmfreq(p, m1, m2=None)

nexus.numerics.morse_harmonic_potential(p, r)

nexus.numerics.morse_spect_fit(re, w, wX, m1, m2=None, Einf=0.0)

nexus.numerics.morse_rDw_fit(re, De, w, m1, m2=None, Einf=0.0, Dunit='eV')

nexus.numerics.morse_fit(r, E, p0=None, jackknife=False, cost=<function least_squares>, auxfuncs=None, auxres=None, capture=None)

nexus.numerics.morse_fit_fine(r, E, p0=None, rfine=None, both=False, jackknife=False, cost=<function least_squares>, capture=None)

nexus.numerics.murnaghan(p, V)

nexus.numerics.birch(p, V)

nexus.numerics.vinet(p, V)

nexus.numerics.murnaghan_pressure(p, V)

nexus.numerics.birch_pressure(p, V)

nexus.numerics.vinet_pressure(p, V)

nexus.numerics.eos_Einf(p)

nexus.numerics.eos_V(p)

nexus.numerics.eos_B(p)

nexus.numerics.eos_Bp(p)

nexus.numerics.eos_eval(p, V, type='vinet')

nexus.numerics.eos_param(p, param, type='vinet')

nexus.numerics.eos_fit(V, E, type='vinet', p0=None, cost='least_squares', jackknife=False, auxfuncs=None, auxres=None, capture=None)

nexus.numerics.jackknife(data, function, args=None, kwargs=None, position=None, capture=None)

nexus.numerics.numerics_jackknife(data, function, args=None, kwargs=None, position=None, capture=None)

nexus.numerics.jackknife_aux(jsamples, auxfunc, args=None, kwargs=None, position=None, capture=None)

nexus.numerics.check_jackknife_inputs(args, kwargs, position)

nexus.numerics.ndgrid(*args, **kwargs)

n-dimensional gridding like Matlab’s NDGRID

Parameters:

*args

An arbitrary number of numerical sequences, e.g. lists, arrays, or tuples.

The i-th dimension of the i-th output argument has copies of the i-th input argument.

same_dtypebool, default False, kwargs

If False (default), the result is an ndarray.

If True, the result is a lists of ndarrays, possibly with different dtype. This can save space if some *args have a smaller dtype than others.

Examples

Typical usage

>>> x, y, z = [0, 1], [2, 3, 4], [5, 6, 7, 8]
>>> X, Y, Z = ndgrid(x, y, z) # unpacking the returned ndarray into X, Y, Z

Each of X, Y, Z has shape [len(v) for v in x, y, z].

>>> X.shape == Y.shape == Z.shape == (2, 3, 4)
True
>>> X
array([[[0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0]],
       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])
>>> Y
array([[[2, 2, 2, 2],
        [3, 3, 3, 3],
        [4, 4, 4, 4]],
       [[2, 2, 2, 2],
        [3, 3, 3, 3],
        [4, 4, 4, 4]]])
>>> Z
array([[[5, 6, 7, 8],
        [5, 6, 7, 8],
        [5, 6, 7, 8]],
       [[5, 6, 7, 8],
        [5, 6, 7, 8],
        [5, 6, 7, 8]]])

With an unpacked argument list:

>>> V = [[0, 1], [2, 3, 4]]
>>> ndgrid(*V) # an array of two arrays with shape (2, 3)
array([[[0, 0, 0],
        [1, 1, 1]],
       [[2, 3, 4],
        [2, 3, 4]]])

For input vectors of different data types, same_dtype=False makes ndgrid() return a list of arrays with the respective dtype.

>>> ndgrid([0, 1], [1.0, 1.1, 1.2], same_dtype=False)
[array([[0, 0, 0], [1, 1, 1]]), 
 array([[ 1. ,  1.1,  1.2], [ 1. ,  1.1,  1.2]])]

Default is to return a single array.

>>> ndgrid([0, 1], [1.0, 1.1, 1.2])
array([[[ 0. ,  0. ,  0. ], [ 1. ,  1. ,  1. ]],
       [[ 1. ,  1.1,  1.2], [ 1. ,  1.1,  1.2]]])

nexus.numerics.simstats(x, dim=None)

nexus.numerics.simplestats(x, dim=None, full=False)

nexus.numerics.equilibration_length(x, tail=0.5, plot=False, xlim=None, bounces=2, random=True, seed_from_hash=True)

nexus.numerics.ttest(m1, e1, n1, m2, e2, n2)

nexus.numerics.surface_normals(x, y, z)

nexus.numerics.simple_surface(origin, axes, grid)

nexus.numerics.func_fit(x, y, fitting_function, p0, cost=<function least_squares>)

nexus.numerics.distance_table(p1, p2, ordering=0)

nexus.numerics.nearest_neighbors(n, points, qpoints=None, return_distances=False, slow=False)

nexus.numerics.voronoi_neighbors(points)

nexus.numerics.convex_hull(points, dimension=None, tol=None)

nexus.numerics.layers_1d(xpoints, tol, xmin=None, xmax=None, merge=True, periodic=False, full_return=False)

nexus.numerics.layer_means_1d(xpoints, tol, full_return=False)

nexus.numerics.index_by_layer_1d(xpoints, tol, uniform=True, check=True, full_return=False)