def Systematic(data):
List = []
x = len(data) / 5
i = 0
while i < len(data):
List.append(i)
i = addition(i, x)
return List
def median(lst):
lst.sort()
if len(lst) % 2 == 0:
first_median = lst[len(lst) // 2]
second_median = lst[len(lst) // 2 - 1]
median = division(addition(first_median, second_median), 2)
else:
median = lst[len(lst) // 2]
return median
def standard_deviation(numbers): # complete
n = len(numbers)
c = 0
t = 0
for i in range(0, n, 1):
c = subtraction(mean(numbers), numbers[i])
t = addition(square(c), t)
x = division((n - 1), t)
return root(x)
def Median(data):
n = len(data)
num = n // 2
if n % 2 == 0:
mid = (addition(data[num], data[num - 1])) / 2
print(data[num])
else:
mid = data[num]
print(data[mid])
return mid
def confidence_interval(data):
z_value = 1.05
mean =sample_mean(data)
sd = pop_standard_dev(data)
x = len(data)
y = division(squareroot(x), sd)
margin_of_error = multiplication(z_value, y)
a = subtraction(mean, margin_of_error)
b = addition(mean, margin_of_error)
return a, b
def median(numbers):
n = len(numbers)
numbers.sort()
if n % 2 == 0:
first_median = numbers[int(division(2, n))]
second_median = numbers[len(numbers) // 2 - 1]
med = division(2, addition(first_median, second_median))
else:
med = numbers[division(2, n)]
return med
def confidence_interval(numbers):
m = mean(numbers)
confidence_level = 0.95
z = (1 - confidence_level) / 2
sd = standard_deviation(numbers)
n = root(len(numbers))
return [
subtraction(multiplication(division(n, sd), z), m),
addition(multiplication(division(n, sd), z), m)
]
def psd(numbers):
num_values = len(numbers)
result = mean(numbers)
total = 0
for numb in numbers:
result2 = subtraction(numb, result)
sq = squaree(result2)
total = addition(total, sq)
return squar_rot(division(num_values, total))
def mean(data):
try:
num_values = len(data)
total = 0
for num in data:
total = addition(total, num)
return division(num_values, total)
except ZeroDivisionError:
print("Error - Cannot divide by 0")
except ValueError:
print("Error - Invalid data inputs")
def mean(data):
# Validations
empty_list_check(data)
check_for_valid_numbers(data)
num_values = len(data)
total = 0
for num in data:
total = addition(total, num)
return division(num_values, total)
def variance(data):
# Validations
empty_list_check(data)
check_for_valid_numbers(data)
n = len(data)
calculated_mean = mean(data)
result = 0
for x in data:
result = addition(square(subtraction(calculated_mean, x)), result)
return division(n, result)
def proportion(num):
sum = 0
for n in num:
sum = addition(sum, n)
result = []
for n in num:
value = division(n, sum)
result.append(value)
return result
def sample_mean(data, sample_size):
total = 0
# check that get sample returns the proper number of samples
# check that sample size is not 0
# check that sample size is not larger than the population
# https://realpython.com/python-exceptions/
# https://stackoverflow.com/questions/129507/how-do-you-test-that-a-python-function-throws-an-exception
sample = getSample(data, sample_size)
num_values = len(sample)
for num in sample:
total = addition(total, num)
return division(total, num_values)
def samp_st_dev(numbers):
ss = random.randint(1, len(numbers))
new_values = getSample(numbers, ss)
c = 0
t = 0
n = len(new_values)
for i in range(0, n, 1):
c = subtraction(new_values[i], mean(new_values))
t = addition(square(c), t)
x = division(subtraction(1, n), t)
actual_sd = statistics.stdev(new_values) # Calculated using stat library to compare
return root(x), actual_sd
def population_correlation_coefficient(list_x, list_y):
total = 0
x = standard_deviation(list_x)
y = standard_deviation(list_y)
for i in range(len(list_x)):
diff_x = subtraction(list_x[i], mean(list_x))
diff_y = subtraction(list_y[i], mean(list_y))
total = total + multiplication(division(diff_x, x), division(
diff_y, y))
return round(
float(
multiplication(division(1, addition(len(list_x), len(list_y))),
total)), 4)
def quartiles(data):
try:
List2 = []
num_values = len(data)
nNum = float(num_values)
Q2 = median(data)
nSort = sorted(data)
a = .25 * nNum
b = .75 * nNum
for num in nSort:
List2.append(num)
Q1 = List2[int(a)]
Q3 = List2[int(b)]
bb = addition(addition(int(Q1), int(Q2)), int(Q3))
return int(Q1), int(Q2), int(Q3)
except ZeroDivisionError:
print("Error - Cannot divide by 0")
except ValueError:
print("Error - Invalid data inputs")
def sample_std_dev(data):
total = 0
samples = random.randint(1, len(data))
new_samples = get_sample(data, samples)
new_mean = population_mean(new_samples)
for number in new_samples:
result = subtraction(number, new_mean)
sq = square(result)
total = addition(total, sq)
n = len(new_samples)
d = division(subtraction(1, n), total)
sample_sd = sq_rt(d)
return sample_sd
def sample_st_deviation(data, sample_size):
dev = 0
sample = getSample(data, sample_size)
sample_values = len(sample)
x_bar = sample_mean()
x = sample_values
n = subtraction(sample_values, 1)
for dev in sample:
dev = subtraction(x, x_bar)
square_x_bar = square(dev)
add = addition(square_x_bar, square_x_bar)
divide = division(add, n)
return squareroot(divide)
def variance(num):
try:
pop_mean = populationmean(num)
num_values = len(num)
x = 0
for i in num:
# x = x + square(i-pop_mean)
x = addition(x, square(subtraction(i, pop_mean)))
return division(x, num_values)
except ZeroDivisionError:
print("Error: Enter number greater than 0")
except ValueError:
print("Error: Enter correct data type")
def get_median(data):
num_values = len(data)
if num_values % 2 == 0:
value = int(division(2, num_values))
a = data[value]
value = value - 1
b = data[value]
c = addition(b, a)
d = division(2, c)
return d
else:
value = int(division(2, num_values))
e = data[value]
return e
def ssd(data):
total = 0
sample = random.randint(1, len(data))
new_sample = getSample(data, sample)
new_mean = mean(new_sample)
for numb in new_sample:
result = subtraction(numb, new_mean)
sq = squaree(result)
total = addition(total, sq)
n = len(new_sample)
d = division(subtraction(1, n), total)
samp_sd = squar_rot(d)
# actual_sd = statistics.stdev(new_sample)
return samp_sd
def mode(num):
counter = {}
for n in num:
if n in counter:
counter[n] = addition(counter[n],1)
else:
counter[n] = 1
result = None
maxCount = 0
for k in counter.keys():
if counter[k] > maxCount:
maxCount = counter[k]
result = k
return float(result)
def get_variance(data):
x1 = get_mean(data)
num_values = len(data)
total = 0
total1 = 0
data1 = []
for i in range(0, len(data)):
a = data[i - 1]
total_sum = subtraction(a, x1)
total = square(total_sum)
data1.append(total)
for i in range(0, len(data1)):
total1 = total1 + addition(0, data1[i])
return round(division(num_values - 1, total1), 1)
def median(num):
num1 = sorted(num)
values = len(num1)
num1.sort()
if values % 2 == 0:
median1 = num1[values // 2]
median2 = num1[int(subtraction((values // 2), 1))]
median = division(addition(median1, median2), 2)
else:
median = num1[values // 2]
return median
def sample(data, sample_size):
total = 0
# check that get sample returns the proper number of samples
# check that sample size is not 0
# check that sample size is not larger than the population
if sample_size != 0
raise Exception('sample_size cannot be 0')
if sample_size > data
raise NotLargerThanDataException('sample_size cannot be bigger than population')
random_values = getRandomNum(data, sample_size)
num_values = len(random_values)
for num in random_values:
total = addition(total, num)
return division(total, num_values)
def median(num):
try:
num_values = len(num)
list_num = [num[i] for i in range(num_values)]
list_num.sort()
if num_values % 2 == 0:
median1 = list_num[int(num_values // 2)]
median2 = list_num[int(subtract((num_values // 2), 1))]
median_result = division(addition(median1, median2), 2)
else:
median_result = list_num[int(division(num_values, 2))]
return median_result
except ZeroDivisionError:
print("Divide by 0 Error")
except ValueError:
print("Please Check your data inputs")
def median(a):
try:
n = len(a)
list_num = [a[i] for i in range(n)]
list_num.sort()
if n % 2 == 0:
median1 = list_num[int(n // 2)]
median2 = list_num[int(subtraction((n // 2), 1))]
median_result = division(addition(median1, median2), 2)
else:
median_result = list_num[int(division(n, 2))]
return median_result
except ZeroDivisionError:
print("Error: Can't Divide by 0")
except ValueError:
print("Error: Check your data inputs")
def median(num):
try:
num_values = len(num)
list_num = [num[i] for i in range(num_values)]
list_num.sort()
if num_values % 2 == 0:
median1 = list_num[int(num_values // 2)]
median2 = list_num[int(subtraction((num_values // 2), 1))]
median_result = division(addition(median1, median2), 2)
else:
median_result = list_num[int(division(num_values, 2))]
return median_result
except ZeroDivisionError:
print("Error: Enter numbers greater than 0")
except ValueError:
print("Error: insert correct data type ")
def median(num):
try:
num_values = len(num)
list_num = [num[i] for i in range(num_values)]
list_num.sort()
if num_values % 2 == 0:
median1 = list_num[int(num_values / 2) - 1]
median2 = list_num[int(subtraction((num_values // 2), 1))]
median_result = division(2, addition(median1, median2))
else:
median_result = list_num[math.ceil(division(2, num_values)) - 1]
return float(median_result)
except ZeroDivisionError:
print("Error - Cannot divide by 0")
except ValueError:
print("Error - Invalid data inputs")
def confidence_interval(data):
z_value = 1.960
mean = population_mean(data)
sd = pop_stand_dev(data)
x = len(data)
y = division(sq_rt(x), sd)
margin_of_error = multiplication(z_value, y)
a = [subtraction(mean, margin_of_error)]
b = [addition(mean, margin_of_error)]
size = len(a)
lower = a[0]
upper = b[0]
return lower, upper
