def unknown_pop_stand_deviation(data, confidenceZscore, marginOfError,
percentSample):
try:
z = confidenceZscore
if isinstance(marginOfError, float):
moe = marginOfError
else:
moe = division(marginOfError, 100)
if isinstance(percentSample, float):
percent = percentSample
else:
percent = division(percentSample, 100)
e = division(moe, 2)
p = subtraction(1, percent)
sample_muliply = multiplication(p, percent)
z_by_e = division(z, e)
squared = square(z_by_e)
result = multiplication(sample_muliply, squared)
return result
except ValueError:
print("ERROR: That is an emtpy array! Try again.")
def median(data):
try:
total_values = len(data)
list_of_nums = [data[i] for i in range(total_values)]
list_of_nums.sort()
if total_values % 2 == 0:
median1 = list_of_nums[int(total_values // 2)]
median2 = list_of_nums[int(subtraction((total_values // 2), 1))]
result = division(addition(median1, median2), 2)
else:
result = list_of_nums[int(division(total_values, 2))]
return result
except ValueError:
print("ERROR: That is an emtpy array! Try again.")
def samplestand(data, sample_size):
dev = 0
sample = sampledata(data, sample_size)
sample_values = len(sample)
x_bar = 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)
result = division(add, n)
return squareroot(result)
def sampmean(samplesize, a, b, c, d, e):
try:
a = float(a)
b = float(b)
c = float(c)
d = float(d)
e = float(e)
samplesize = int(samplesize)
data = []
data.append(a)
data.append(b)
data.append(c)
data.append(d)
data.append(e)
sample = []
for i in range(1, samplesize):
sample.append(int(data[i]))
total_n = len(sample)
sum = 0
for i in sample:
sum = addition(sum, i)
mean = division(total_n, sum)
return mean
except ZeroDivisionError:
print("Divide by Zero Error")
except ValueError:
print("Only float arguments are valid.")
def zscore(data):
x=64
u=mean(data)
sample_sd=samplestand(data)
y=subtraction(x,u)
return division(sample_sd,y)
def proportion(numbers):
num_value = len(numbers)
result = 0
for num in numbers:
if result > 64:
addition(result, result)
return division(num, num_value)
def zscore(numbers):
row_value = 151
sd = psd(numbers)
m = mean(numbers)
result = subtraction(row_value, m)
z_score = division(result, sd)
print(z_score)
return z_score
def pop_corr_coeff(numbers):
num_value = len(numbers)
# Calculation of covariance
result1 = subtraction(numbers, sample_mean)
result2 = subtraction(numbers, sample_mean)
result3 = multiplication(result1, result2)
covariance = division(num_value, sum(result3))
# denominator
data1 = CsvReader('Tests/Data/pop_corr_data1').numbers
data2 = CsvReader('Tests/Data/pop_corr_data2').numbers
result4 = psd(data1)
result5 = psd(data2)
result6 = multiplication(result4, result5)
population_corr_coeff = division(result6, covariance)
return population_corr_coeff
def vsp(data):
random_data = random.randint(1, len(data))
new_data = Getsample(data, random_data)
prop = proportion(new_data)
result1 = multiplication(prop, subtraction(prop, 1))
y = subtraction(len(new_data), 1)
x = division(result1, y)
return x
def cochran_sample_size(data, confidenceLevel, confidencelevelZscore,
testVaribility):
try:
numvalues = len(data)
precision = subtraction(1.00, confidenceLevel)
z = confidencelevelZscore
p = testVaribility
recommendation = division(
multiplication(square(z), multiplication(p, p)), square(precision))
cochran = division(
recommendation,
addition(1, (division(subtraction(recommendation, 1), numvalues))))
return round(cochran, 2)
except ValueError:
print("ERROR: That is an emtpy array! Try again.")
def conf_interval(data):
x = mean(data)
dev = psd(data)
z = 1.96 # for 95% confidence
standard_error = division(dev, squareroot(len(data)))
conf_upper_level = round(addition(x, multiplication(z, standard_error)), 2)
conf_lower_level = round(subtraction(multiplication(z, standard_error), x), 2)
return conf_upper_level, conf_lower_level
def popuvar(numbers):
num_value = len(numbers)
total = 0
for numb in numbers:
result = subtraction(numb, mean(numb))
result1 = square(result)
result2 = division(num_value, result1)
return result2
def mean(data):
try:
total_values = len(data)
total = 0
for num in data:
total = addition(total, num)
return division(total, total_values)
except ValueError:
print("ERROR: That is an emtpy array! Try again.")
def variance(nums):
length = len(nums)
mn = mean(nums)
x = 0
for i in nums:
x = x + squared(i - float(mn))
return division(x, length)
def confidence_interval(numbers):
num_value = len(numbers)
result = popstand(numbers)
result2 = squareroot(num_value)
sample_error = division(result2, result)
margin_error = multiplication(
1.96, sample_error) # 1.96=z_value for 95% confidence interval
result4 = addition(result, margin_error)
result5 = subtraction(margin_error, result)
return result4, result5
def vpop(numbers):
num_values = len(numbers)
result = mean(numbers)
total = 0
for numb in numbers:
result2 = subtraction(numb, result)
sq = square(result2)
total = addition(total, sq)
return division(num_values, total)
def var_sample_prop(numbers, size):
result = 0
data = dataList(numbers, size)
num_value = len(data)
result1 = proportion(numbers)
result2 = subtraction(1, result1)
result3 = subtraction(num_value, 1)
for data2 in data:
result4 = multiplication(result1, result2)
return division(result4, result3)
def margin_of_error (data, confidence_Zscore):
try:
size = len(data)
std = standard_deviation(data)
z = confidence_Zscore
moe = multiplication(z, division(std, squareRoot(size)))
return round(moe, 5)
except ValueError:
print("ERROR: That is an emtpy array! Try again.")
def sample_mean(data):
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
num_values = len(data)
for num in data:
total = addition(total, num)
return division(total, num_values)
def variance(data):
try:
mean_of_data = mean(data)
total_values = len(data)
v = 0
for a in data:
v = v + square(a - mean_of_data)
result = division(v, total_values)
return result
except ValueError:
print("ERROR: That is an emtpy array! Try again.")
def confidenceIntervalTop(data, confidence_level):
try:
values = len(data)
std = standard_deviation(data)
avg = mean(data)
rounded_interval = stats.norm.interval(
confidence_level, avg, division(std, squareRoot(values)))
intervalBottom = round(rounded_interval[1], 5)
return intervalBottom
except ValueError:
print("ERROR: That is an emtpy array! Try again.")
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 = square(result)
total = addition(total, sq)
n = len(new_sample)
d = division(subtraction(1, n), total)
samp_sd = squareroot(d)
return samp_sd
def calculate():
operation = input('''
Please type in the math operation you would like to complete:
+ for addition
- for subtraction
* for multiplication
/ for division
** for power
% for modulo
cos for cosinus
sin for sinus
tan for tangent
exp for exponentiel
log for logarithm
''')
#Correct operator
if operation in ('+', '-', '*', '/', '**', '%', 'cos', 'sin', 'tan', 'exp',
'log'):
number_1 = float(input('Enter your first number: '))
number_2 = float(input('Enter your first number: '))
else:
print('You have not typed a valid command, please try again.')
again()
if operation == '+':
print(add(number_1, number_2))
elif operation == '-':
print(sub(number_1, number_2))
elif operation == '*':
print(multiply(number_1, number_2))
elif operation == '/':
print(division(number_1, number_2))
elif operation == '**':
print(power(number_1, number_2))
elif operation == '%':
print(modulo(number_1, number_2))
elif operation == 'cos':
print(cosinus(number_1, number_2))
elif operation == 'sin':
print(sinus(number_1, number_2))
elif operation == 'tan':
print(tangent(number_1, number_2))
elif operation == 'exp':
print(exponentiel(number_1, number_2))
elif operation == 'log':
print(logarythm(number_1, number_2))
def z_score(data):
try:
zscore_list = []
for x in data:
zmean = mean(data)
standard_dev = standard_deviation(data)
diff = subtraction(x, zmean)
z = division(diff, standard_dev)
roundedz = round(z, 5)
zscore_list.append(roundedz)
return zscore_list
except ValueError:
print("ERROR: That is an emtpy array! Try again.")
def popmean(a, b, c):
try:
a = float(a)
b = float(b)
c = float(c)
data = []
data.append(a)
data.append(b)
data.append(c)
total_n = len(data)
sum = 0
for i in data:
sum = addition(sum, i)
mean = division(total_n, sum)
pprint(mean)
return mean
except ZeroDivisionError:
print("Divide by Zero Error")
except ValueError:
print("Only float arguments are valid.")
def divide(self, a, b):
self.result = division(a, b)
return self.result
def var_pop_prop(data):
prob_poss = proportion(data)
prob_imposs = subtraction(prob_poss, 1)
result = multiplication(prob_imposs, prob_poss)
vpp = division(result, len(data))
return vpp
def divide(self, a, b):
self.result = division(a, b)
return round(float(self.result), 7)
def div(self, a, b):
self.result = division(b, a)
return self.result
def mean(data):
num_values = len(data)
total = 0
for num in data:
total = addition(total, num)
return division(num_values, total)
