def cohend(d1, d2):
# calculate the size of samples
n1, n2 = len(d1), len(d2)
# calculate the variance of the samples
s1, s2 = math.var(d1, ddof=1), math.var(d2, ddof=1)
# calculate the pooled standard deviation
s = math.sqrt(((n1 - 1) * s1 + (n2 - 1) * s2) / (n1 + n2 - 2))
# calculate the means of the samples
u1, u2 = math.mean(d1), math.mean(d2)
# calculate the effect size
return (u1 - u2) / s
def update_moving_ave(self, receiver):
"""
Calculate the average rssi using the standard mean of the finite_queue
Returns:
the float value or None if we have 0 entries
"""
if len(self.rssi_val[receiver]) < 1:
self.ave_rssi[receiver] = None
else:
self.ave_rssi[receiver] = math.mean(self.rssi_val[receiver])
def summarize_tuples(pairs, how='min'):
"""summarize collection of tuple with list values"""
summarized_pairs = []
for k, v in pairs.items():
if how == 'min':
summarized_value = min(v)
elif how == 'max':
summarized_value = max(v)
elif how == 'mean':
summarized_value = math.mean(v)
summarized_pairs.append((k[0], k[1], summarized_value))
return summarized_pairs
def getAverageTime(self, startStation: str, endStation: str) -> float:
if (startStation, endStation) in self.times:
return math.mean(self.times[(startStation, endStation)])
else:
return None
# Your UndergroundSystem object will be instantiated and called as such:
# obj = UndergroundSystem()
# obj.checkIn(id,stationName,t)
# obj.checkOut(id,stationName,t)
# param_3 = obj.getAverageTime(startStation,endStation)
def median_item_price(self):
total_items = self.repeated_price_list()
dataLen = len(total_items)
#if length is odd, take middle value, by dividing the length by 2,
#then rounding up
if (dataLen % 2) == 1:
return total_items[round(dataLen / 2)]
#if the length is even, take the mean of the middle two values, which
#have indices length/2 and (length/2 + 1)
elif (dataLen % 2) == 0:
#remember that indices are indexed at 0
return math.mean([
total_items[int(dataLen / 2 - 1)],
total_items[int(dataLen / 2)]
])
def T(self):
self.K * math.mean(self._mi)
def normalize(OO0OOO0OO0O00O0OO): #line:128
print(OO0OOO0OO0O00O0OO /
(math.sqrt(math.mean(math.square(OO0OOO0OO0O00O0OO))) +
1e-5)) #line:129
[x for x in range(3, 15, 3)]
"asdf+sdf".split("+")
a = (1, 2, 3)
a + (1, )
import math
math.ceil(10.3)
s = set()
s.add(3)
s
import math
math.mean([1, 2, 3])
round(2.5)
arr = []
length = len(arr)
i, j = 0, length - 1
while (i < j):
mid = (i + j) // 2
if arr[mid] < k:
i = mid + 1
elif arr[mid] >= k:
j = mid
ls = [
22, 22, 22, 16, 30, 22, 28, 27, 22, 4, 34, 40, 5, 22, 48, 41, 1, 42, 37,
def geometric_mean(x, shift=0):
"""Calculates geometric mean with shift parameter."""
return math.exp(math.mean(math.log(x + shift))) - shift
def _transform_value(px, format):
if format == FORMAT_RGB:
return (int(round(px[0] / 255.0)), int(round(px[1] / 255.0)), int(round(px[2] / 255.0)))
else:
return int(round(math.mean(px) / 255.0))
def get_student_average_gpa(self, weighted=True):
gpa = self.get_student_gpa(weighted=weighted)
return math.mean(gpa)
def pool(dim,
tensor,
kernel_size=3,
stride=None,
dilation=1,
padding=0,
bound='zero',
reduction='mean',
return_indices=False,
affine=None):
"""Perform a pooling
Parameters
----------
dim : {1, 2, 3}
Number of spatial dimensions
tensor : (*batch, *spatial_in) tensor
Input tensor
kernel_size : int or sequence[int], default=3
Size of the pooling window
stride : int or sequence[int], default=`kernel_size`
Strides between output elements.
dilation : int or sequece[int], default=1
Strides between elements of the kernel.
padding : 'auto' or int or sequence[int], default=0
Padding performed before the convolution.
If 'auto', the padding is chosen such that the shape of the
output tensor is `spatial_in // stride`.
bound : str, default='zero'
Boundary conditions used in the padding.
reduction : {'mean', 'max', 'min', 'median', 'sum'} or callable, default='mean'
Function to apply to the elements in a window.
return_indices : bool, default=False
Return input index of the min/max/median element.
For other types of reduction, return None.
affine : (..., D+1, D+1) tensor, optional
Input orientation matrix
Returns
-------
pooled : (*batch, *spatial_out) tensor
indices : (*batch, *spatial_out, dim) tensor, if `return_indices`
affine : (..., D+1, D+1) tensor, if `affine`
"""
# move everything to the same dtype/device
tensor = torch.as_tensor(tensor)
# sanity checks + reshape for torch's conv
batch = tensor.shape[:-dim]
spatial_in = tensor.shape[-dim:]
tensor = tensor.reshape([-1, *spatial_in])
# Perform padding
kernel_size = make_list(kernel_size, dim)
stride = make_list(stride or None, dim)
stride = [st or ks for st, ks in zip(stride, kernel_size)]
dilation = make_list(dilation or 1, dim)
padding = make_list(padding, dim)
padding0 = padding # save it to update the affine
for i in range(dim):
if isinstance(padding[i], str) and padding[i].lower() == 'auto':
if kernel_size[i] % 2 == 0:
raise ValueError('Cannot compute automatic padding '
'for even-sized kernels.')
padding[i] = ((kernel_size[i] - 1) * dilation[i] + 1) // 2
use_torch = reduction in ('mean', 'avg', 'max') and dim in (1, 2, 3)
if (not use_torch) or bound != 'zero' and sum(padding) > 0:
# torch implementation -> handles zero-padding
# our implementation -> needs explicit padding
tensor = utils.pad(tensor, padding, bound, side='both')
padding = [0] * dim
return_indices0 = False
pool_fn = reduction if callable(reduction) else None
if reduction in ('mean', 'avg'):
return_indices0 = True
return_indices = False
pool_fn = (F.avg_pool1d if dim == 1 else F.avg_pool2d
if dim == 2 else F.avg_pool3d if dim == 3 else None)
if pool_fn:
pool_fn0 = pool_fn
pool_fn = lambda x, *a, **k: pool_fn0(
x[:, None], *a, **k, padding=padding, dilation=dilation)[:, 0]
elif reduction == 'max':
pool_fn = (F.max_pool1d if dim == 1 else F.max_pool2d
if dim == 2 else F.max_pool3d if dim == 3 else None)
if pool_fn:
pool_fn0 = pool_fn
pool_fn = lambda x, *a, **k: pool_fn0(
x[:, None], *a, **k, padding=padding, dilation=dilation)[:, 0]
if not pool_fn:
if reduction not in ('min', 'max', 'median'):
return_indices0 = True
return_indices = False
if reduction == 'mean':
reduction = lambda x: math.mean(x, dim=-1)
elif reduction == 'sum':
reduction = lambda x: math.sum(x, dim=-1)
elif reduction == 'min':
reduction = lambda x: math.min(x, dim=-1)
elif reduction == 'max':
reduction = lambda x: math.max(x, dim=-1)
elif reduction == 'median':
reduction = lambda x: math.median(x, dim=-1)
elif not callable(reduction):
raise ValueError(f'Unknown reduction {reduction}')
pool_fn = lambda *a, **k: _pool(*a, **k, reduction=reduction)
outputs = []
if return_indices:
tensor, ind = pool_fn(tensor, kernel_size, stride=stride)
ind = utils.ind2sub(ind, stride)
ind = utils.movedim(ind, 0, -1)
outputs.append(ind)
else:
tensor = pool_fn(tensor, kernel_size, stride=stride)
if return_indices0:
outputs.append(None)
spatial_out = tensor.shape[-dim:]
tensor = tensor.reshape([*batch, *spatial_out])
outputs = [tensor, *outputs]
if affine is not None:
affine, _ = affine_conv(affine,
spatial_in,
kernel_size=kernel_size,
stride=stride,
padding=padding0,
dilation=dilation)
outputs.append(affine)
return outputs[0] if len(outputs) == 1 else tuple(outputs)
def mean_friend_prediction(self):
#see where to add this in the scheduler!!!!
return (math.mean([f.prediction for f in self.friends]))
