Assorted, general numerical methods
| name | arguments | returns |
|---|---|---|
| curve_intersect_interpolate | cls, df: pd.DataFrame, row_index :int, x, var1, var2 | (float, float) |
Fine-tune the intersection point between 2 Pandas dataframe columns,
using linear interpolation
:param df: A Pandas dataframe with at least 3 columns
:param row_index: The index of the Pandas dataframe row
with the smallest absolute value of difference in concentrations
:param x: The name of the dataframe column with the independent variable
:param var1: The name of the dataframe column with the data from the 1st curve
:param var2: The name of the dataframe column with the data from the 2nd curve
:return: The pair (time of intersection, common value)
| ||
| name | arguments | returns |
|---|---|---|
| segment_intersect | cls, t, y1, y2 | (float, float) |
Find the intersection of 2 segments in 2D.
Their respective endpoints share the same x-coordinates: (t_start, t_end)
Note: for an alternate method, see line_intersect()
:param t: Pair with the joint x-coordinates of the 2 start points,
and the joint x-coordinates of the 2 end points
:param y1: Pair with the y_coordinates of the endpoints of the 1st segment
:param y2: Pair with the y_coordinates of the endpoints of the 2nd segment
Note: either segment - but not both - may be horizontal
:return: A pair with the (x,y) coord of the intersection;
if the segments don't meet their specs (which might result in the lack of an intersection),
an Exception is raised
| ||
| name | arguments | returns |
|---|---|---|
| line_intersect | cls, p1, p2, q1, q2 | Union[tuple, None] |
Returns the coordinates of the intersection
between the line passing thru the points p1 and p2,
and the line passing thru the points q1 and q2.
Based on https://stackoverflow.com/a/42727584/5478830
Note: for an alternate method, see segment_intersect()
:param p1: Pair of (x,y) coord of a point on the 1st line
:param p2: Pair of (x,y) coord of another point on the 1st line
:param q1: Pair of (x,y) coord of a point on the 2nd line
:param q2: Pair of (x,y) coord of another point on the 2nd line
:return: A pair with the (x,y) coord of the intersection, if it exists;
or None if it doesn't exist
| ||
| name | arguments | returns |
|---|---|---|
| deep_flatten | cls, items | list |
Completely flatten any lists/tuples of lists or tuples
into a single list
EXAMPLES:
[[1,2,3], [4,5,6], [7], [8,9]] becomes [1, 2, 3, 4, 5, 6, 7, 8, 9]
(1,2) becomes [1,2]
[(1, 2), (3,4)] becomes [1, 2, 3, 4]
5 becomes [5]
"hello" becomes ["hello"]
:param items: A list or tuple possibly containing lists or tuples
:return: A flat list
| ||
| name | arguments | returns |
|---|---|---|
| compare_results | cls, res1, res2 | float |
Use a Euclidean distance metric to compare 2 sets of results - typically from 2 runs
of different accuracy.
Each result value may be a number or a list or tuple, possibly containing lists or tuples,
of numbers.
However, after the structure is flattened,
the 2 result data sets must have the same number of points
:param res1:
:param res2:
:return: The distance between the two sets of value, based on an L2 (Euclidean) metric
| ||
| name | arguments | returns |
|---|---|---|
| compare_vectors | cls, v1: np.array, v2: np.array, metric=None, trim_edges=0 | float |
Return the Euclidean distance between the two given same-sized Numpy arrays
(TODO: offer option to use alternate metrics)
:param v1:
:param v2:
:param metric: NOT YET USED: the default L2 norm is always used
:param trim_edges: (OPTIONAL) number of elements to ditch at each end,
prior to comparing the vectors (default: 0)
:return: The distance between the two vectors based on an L2 (Euclidean) metric
| ||
| name | arguments | returns |
|---|---|---|
| compare_states | cls, state1: np.array, state2: np.array, verbose=False | None |
Print out various assessments of how similar two same-sized Numpy arrays are.
Typically, those arrays will be system state snapshots - but could be anything.
:param state1:
:param state2:
:param verbose: If True, additional output is shown
:return: None
| ||
| name | arguments | returns |
|---|---|---|
| gradient_order4_1d | cls, arr, dx=1.0, dtype='float' | np.array |
Compute the gradient, from the values in the given array,
using the 5-point Central Difference, which produces an accuracy of order 4.
At the boundary, or close to it, different 5-point stencils are used,
still resulting in an accuracy of order 4.
For the coefficients, see: https://web.media.mit.edu/~crtaylor/calculator.html
Returns the same size as the input array.
For multi-dimensional cases, use gradient_order4()
For a simpler, but less accurate (order 2) approach, simply use Numpy gradient()
:param arr: One-dimensional Numpy array (or list, or tuple) of numbers,
with at least 5 elements
:param dx: Delta_x (assumed constant)
:param dtype: Data type to use for the elements of the returned array
:return: A Numpy array with the same size as the one passed in arr
| ||
| name | arguments | returns |
|---|---|---|
| gradient_order4 | cls, f: np.array, *varargs | Union[np.array, list] |
Compute the gradient, from the values in the given (possibly multidimensional) array,
using the 5-point Central Difference, which produces an accuracy of order 4.
At the boundary, and at the points immediately adjacent to the boundary,
simple 2-point forward or backward differences are used (accuracy order 1.)
It returns a list of ndarrays (or a single ndarray if there is only 1 dimension).
Each list element has the same shape as the original array,
and corresponds to the derivatives of the passed array with respect to each dimension.
For 1-dimensional cases, can also use gradient_order4_1d(), which produces accuracy order 4 at ALL points.
(ADAPTED FROM https://gist.github.com/deeplycloudy/1b9fa46d5290314d9be02a5156b48741 , which is
based on 2nd order version from http://projects.scipy.org/scipy/numpy/browser/trunk/numpy/lib/function_base.py
:param f: An N-dimensional array giving samples of a scalar function
:param varargs: 0, 1, or N scalars giving the sample distances in each direction
:return: A list of N numpy arrays,
each of the same shape as f giving the derivative of f with respect to each dimension
| ||
| name | arguments | returns |
|---|---|---|
| expand_matrix_boundary | cls, m | np.array |
Add a row at the top and at the bottom, and also add a column to the left and to the right,
repeating the edge values of the matrix
EXAMPLE: [[1, 2],
[3, 4]]
will turn to
[[1, 1, 2, 2],
[1, 1, 2, 2],
[3, 3, 4, 4],
[3, 3, 4, 4]]
Note how the original matrix is "embedded" in the center of the larger one
:param m: A Numpy matrix
:return: A Numpy matrix, with 2 extra rows (at top and bottom) and 2 extra columns (at left and right)
| ||