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 Sample_Correlation(list1, list2):
n = len(list1)
avg_x = average(list1)
avg_y = average(list2)
rod = 0
x2 = 0
y2 = 0
for i in range(n):
x = subtraction(list1[i], avg_x)
y = subtraction(list2[i], avg_y)
rod += product(x, y)
x2 += square(x)
y2 += square(y)
return rod / squareRoot(x2 * y2)
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 StandardDeviationPopulation(data):
Sum1 = 0
for i in data:
x = abs(i - mean(data))
Sum1 = square(x) + Sum1
n = len(data)
stand_dev = math.sqrt(Sum1) / n
return stand_dev
def StandardDeviationSample(data):
Sum = 0
for i in data:
x = abs(i - mean(data))
Sum = square(x) + Sum
n = len(data)
stand_dev = math.sqrt(Sum / (n - 1))
return stand_dev
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 population_variance(a, b, c, d, e, f):
try:
popstd = population_standard_deviation(a, b, c, d, e, f)
answer = float(square(popstd))
return answer
except ZeroDivisionError:
print("Cannot divide by zero")
except ValueError:
print("Numbers are not valid")
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 CochranSampleSize(data):
p = 0.5
q = 1 - p
PQ = product(p, q)
List = []
List1 = []
for i in MarginError(data):
List.append(square(i))
for i in Z_scores(z_values(data)):
List1.append(square(i))
i = 0
n = []
while i < len(List):
n.append(round(product(List[i], PQ) / List1[i]))
i += 1
return n
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 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 SampleSize_withStd(data):
List = []
List1 = []
E = MarginError(data)
K = mean_confidence_interval(data)
for i in K:
Z = i[1] / 2
List.append(scipy.stats.norm.cdf(Z))
i = 0
while i < len(List):
x = product(List[i], StandardDeviationSample(data))
y = round(division(x, E[i]))
List1.append((square(y)))
i += 1
return List1
def SampleSize_withoutStd(data):
E = MarginError(data) # return a list
p = 0.5
q = 1 - p
PQ = product(q, p)
List = []
List1 = []
x = mean_confidence_interval(data)
for i in x:
Z = i[1] / 2
List.append(scipy.stats.norm.cdf(Z))
ME = []
for i in E:
ME.append(i / 2)
i = 0
while i < len(ME):
ZE = List[i] / ME[i]
x = round(square(ZE) * PQ)
List1.append(x)
i += 1
return List1
def square(self, a):
if not Helper.check_number(a):
raise ValueError
self.result = square(a)
return self.result
def square(self, a):
self.result = square(a)
return self.result
