Add Geometric Mean characteristic calculator for masked arrays

[ChainsManipulator]

Add calculator function for Geometric Mean characteristic for given intervals array using formula:
$$\displaystyle \Delta_{g j}=\sqrt[n_j]{V_j} = \sqrt[n_j]{\prod_{i=1}^{n_j} \Delta_{ij}}$$
Where $\Delta_{ij}$ is an interval and $n_j$ is number of intervals in the given congeneric sequence.

Examples

X = [2, 4, 2, 2, 4]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [1.259921, 2,44948974]

X = [1, 2, 3]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [1, 2, 3]

X = [1, 2, 3]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [3, 2, 1]

X = ['B','B','B','A','A','B','B','A','B','B']
mask = [1, 1, 1, 0, 0, 1, 1, 0, 1, 1]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Lossy')
result = geometric_mean(x_intervals)
print(result)
> [1.7321]

X = ['B','B','B','A','A','B','B','A','B','B']
mask = [1, 1, 1, 0, 0, 1, 1, 0, 1, 1]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [2.2894]

X = ['B','B','B','A','A','B','B','A','B','B']
mask = [1, 1, 1, 0, 0, 1, 1, 0, 1, 1]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [2.0801]

X = ['B','B','B','A','A','B','B','A','B','B']
mask = [1, 1, 1, 0, 0, 1, 1, 0, 1, 1]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Redundant')
result = geometric_mean(x_intervals)
print(result)
> [2.4495]

X = ['B','B','B','A','A','B','B','A','B','B']
mask = [1, 1, 1, 0, 0, 1, 1, 0, 1, 1]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Cycle')
result = geometric_mean(x_intervals)
print(result)
> [2.6207]

X = ['A','A','A','B','A','B','B','A','A','A','A','B','A','A','A']
mask = [1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Lossy')
result = geometric_mean(x_intervals)
print(result)
> [2.1544]

X = ['A','A','A','B','A','B','B','A','A','A','A','B','A','A','A']
mask = [1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [2.5149]

X = ['A','A','A','B','A','B','B','A','A','A','A','B','A','A','A']
mask = [1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [2.5149]

X = ['A','A','A','B','A','B','B','A','A','A','A','B','A','A','A']
mask = [1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Redundant')
result = geometric_mean(x_intervals)
print(result)
> [2.7595]

X = ['A','A','A','B','A','B','B','A','A','A','A','B','A','A','A']
mask = [1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Cycle')
result = geometric_mean(x_intervals)
print(result)
> [2.8925]

X = ['B']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Lossy')
result = geometric_mean(x_intervals)
print(result)
> [0]

X = ['B']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [1]

X = ['B']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [1]

X = ['B']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Redundant')
result = geometric_mean(x_intervals)
print(result)
> [1]

X = ['B']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Cycle')
result = geometric_mean(x_intervals)
print(result)
> [1]

X = ['A','A','A','A','A','A','A','B']
mask = [1, 1, 1, 1, 1, 1, 1, 0]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Lossy')
result = geometric_mean(x_intervals)
print(result)
> [0]

X = ['A','A','A','A','A','A','A','B']
mask = [1, 1, 1, 1, 1, 1, 1, 0]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [8]

X = ['A','A','A','A','A','A','A','B']
mask = [1, 1, 1, 1, 1, 1, 1, 0]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [1]

X = ['A','A','A','A','A','A','A','B']
mask = [1, 1, 1, 1, 1, 1, 1, 0]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Redundant')
result = geometric_mean(x_intervals)
print(result)
> [2.8284]

X = ['A','A','A','A','A','A','A','B']
mask = [1, 1, 1, 1, 1, 1, 1, 0]
masked_X = ma.masked_array(X, mask)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Cycle')
result = geometric_mean(x_intervals)
print(result)
> [8]

X = ['A','A','A','A','A']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Lossy')
result = geometric_mean(x_intervals)
print(result)
> [1]

X = ['A','A','A','A','A']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [1]

X = ['A','A','A','A','A']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Normal')
result = geometric_mean(x_intervals)
print(result)
> [1]

X = ['A','A','A','A','A']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Redundant')
result = geometric_mean(x_intervals)
print(result)
> [1]

X = ['A','A','A','A','A']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Cycle')
result = geometric_mean(x_intervals)
print(result)
> [1]

Inequalities with arithmetic mean

X = [38, 9, 38, 9, 38, 9]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Lossy')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [38, 9, 38, 9, 38, 9]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Lossy')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [38, 9, 38, 9, 38, 9]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [38, 9, 38, 9, 38, 9]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Normal')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [38, 9, 38, 9, 38, 9]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Redundant')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [38, 9, 38, 9, 38, 9]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Redundant')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [38, 9, 38, 9, 38, 9]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Cycle')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [38, 9, 38, 9, 38, 9]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Cycle')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

---

X = [2, 2, 1, 2, 2]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Lossy')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [2, 2, 1, 2, 2]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Lossy')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [2, 2, 1, 2, 2]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [2, 2, 1, 2, 2]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Normal')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [2, 2, 1, 2, 2]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Redundant')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [2, 2, 1, 2, 2]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Redundant')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [2, 2, 1, 2, 2]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Cycle')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [2, 2, 1, 2, 2]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Cycle')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

---

X = ['G','G','G','G']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Lossy')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = ['G','G','G','G']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Lossy')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = ['G','G','G','G']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = ['G','G','G','G']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Normal')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = ['G','G','G','G']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Redundant')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = ['G','G','G','G']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Redundant')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = ['G','G','G','G']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Cycle')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = ['G','G','G','G']
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Cycle')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

---

X = [58, 58, 100, 100]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Lossy')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [58, 58, 100, 100]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Lossy')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [58, 58, 100, 100]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [58, 58, 100, 100]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Normal')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [58, 58, 100, 100]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Redundant')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [58, 58, 100, 100]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Redundant')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [58, 58, 100, 100]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Cycle')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

X = [58, 58, 100, 100]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Cycle')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true
print(delta_g[1] <= delta_a[1])
> true

---

X = [1]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Lossy')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = [1]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Lossy')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = [1]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Normal')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = [1]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Normal')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = [1]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Redundant')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = [1]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Redundant')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = [1]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'Start', 'Cycle')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true

X = [1]
masked_X = ma.masked_array(X)
order, alphabet = ma.order(masked_X, True)
x_intervals = ma.intervals(order, 'End', 'Cycle')
delta_g = geometric_mean(x_intervals)
delta_a = arithmetic_mean(x_intervals)
print(delta_g[0] <= delta_a[0])
> true