def confidence_interval(numbers): m = mean(numbers) confidence_level = 0.95 z = (1-confidence_level) / 2 sd = standard_deviation(numbers) n = squareroot(len(numbers)) return [subtraction(multiplication(division(n, sd), z), m), addition(multiplication(division(n, sd), z), m)]
def sample_size_unknown_pop(confidence_level, width): p = 0.5 q = 1 - p return round( multiplication( square( division(division(2, width), calculate_zvalue(confidence_level))), multiplication(p, q)), 2)
def cochran(p, q, z, e): try: n1 = multiplication(p, p) n2 = z * z n3 = multiplication(n1, n2) n4 = e * e nCochran = division(n4, n3) return int(nCochran) except ZeroDivisionError: print("Error: Can't Divide by 0") except ValueError: print("Error: Check your data inputs")
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 cochran(sample, confidence_level): # Validations check_for_valid_numbers(sample) empty_list_check(sample) # Formula: (Z^2)(p)(q) / (e^2) -> https://www.statisticshowto.com/probability-and-statistics/find-sample-size/ # Assuming p is 0.5 # calculate z from a given confidence interval z = CalculateZValue.calculate_zvalue(confidence_level) margin_of_error_result = square(margin_of_error(sample, confidence_level)) return division(margin_of_error_result, multiplication(multiplication(square(z), 0.5), 0.5))
def variance_of_population_proportion(numbers): n = len(numbers) prop = proportion(numbers) prop_2 = subtraction(prop, 1) x = multiplication(prop, prop_2) variance_of_pp = division(x, n) return variance_of_pp
def Pop_correlation_coefficient(): lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] x_data = [1, 25, 34, 4, 51] y_data = [6, 7, 8, 9, 10] x_mean = mean(x_data) y_mean = mean(y_data) a = [] b = [] ab = [] x = st_dev(x_data) y = st_dev(y_data) divisor = multiplication(x, y) z = len(lst) for i in x_data: new1 = subtraction(x_mean, i) zx = division(new1, x) a.append(zx) # (zx)i = (xi – x̄) / s x for i in y_data: new2 = subtraction(y_mean, i) zy = division(new2, y) b.append(zy) ab = [a[i] * b[i] for i in range(len(x_data))] tot_sum = sum(ab) result = tot_sum / 4 return result
def Pop_correlation_coefficient(x_data, y_data): x_mean = mean(x_data) y_mean = mean(y_data) a = [] b = [] tot_sum = 0 x = st_dev(x_data) y = st_dev(y_data) for i in x_data: new1 = subtraction(x_mean, i) zx = division(new1, x) a.append(zx) for i in y_data: new2 = subtraction(y_mean, i) zy = division(new2, y) b.append(zy) for i in range(len(x_data)): ab = multiplication(a[i], b[i]) tot_sum = addition(tot_sum, ab) cal_result = division(tot_sum, subtraction(1, len(x_data))) return cal_result
def variance_samp_prop(numbers): ran = random.randint(1, len(numbers)) values = getSample(numbers, ran) p = proportion(values) m = multiplication(p, subtraction(p, 1)) x = subtraction(len(values), 1) h = division(x, m) return h
def v_samp_proportion(lst): ss = random.randint(1, len(lst)) new_values = getSample(lst, ss) p = proportion(new_values) c = multiplication(p, subtraction(p, 1)) y = subtraction(len(new_values), 1) x = division(c, y) return x
def confidenceinterval(lst, conf): x = mean(lst) std = standard_deviation(lst) if conf == 95: t = 1.96 elif conf == 90: t = 1.64 elif conf == 99: t = 2.58 else: # 95 default confidence percentage t = 1.96 std_error = division(std, root(len(lst))) conf_upper = addition(x, multiplication(t, std_error)) conf_upper = round(conf_upper, 2) conf_lower = subtraction(multiplication(t, std_error), x) conf_lower = round(conf_lower, 2) return conf_upper, conf_lower
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 var_sample_proportion(data): sample_data = data[0:999] sample_prop_data = [] for x in sample_data: if x > 64: sample_prop_data.append(x) sample_len = len(sample_prop_data) sample_len_data = len(sample_data) p = round(sample_len / sample_len_data, 6) q = subtraction(1, p) return round(multiplication(p, q) / (sample_len_data - 1), 6)
def cimarginerror(n, x, s): try: zValue = 1.96 n1 = square_root(n) n2 = division(n1, s) n3 = multiplication(n2, zValue) return round(float(n3), 2) except ZeroDivisionError: print("Error: Can't Divide by 0") except ValueError: print("Error: Check your data inputs")
def margin_of_error(sample, confidence_level): # Validations empty_list_check(sample) check_for_valid_numbers(sample) # Formula - z * (o / sqrt(n)); o is our standard deviation # Reference - https://www.surveymonkey.com/mp/margin-of-error-calculator/ z = CalculateZValue.calculate_zvalue(confidence_level) sample_size = len(sample) standard_deviation_result = standard_deviation(sample) return multiplication( z, division(square_root(sample_size), standard_deviation_result))
def correlation(data1, data2, seed): # population sample with seed pop1 = ItemReturnType.aList_seed(data1, 5, seed) pop2 = ItemReturnType.aList_seed(data2, 5, seed) cv = Covariance.covariance(pop1, pop2) stdDev1 = StandardDeviation.standard_deviance(pop1) stdDev2 = StandardDeviation.standard_deviance(pop2) sc = cv / (multiplication(stdDev1, stdDev2)) return sc
def confidence_intervals(data): try: zvalue = 1.960 nLenght = len(data) nMean = mean(data) sd = stddev(data) pprint(sd) CI = multiplication(zvalue, (division(square_root(nLenght), sd))) x = round(float(CI), 1) pprint(str(str(nMean) + "+" + str(x))) return str(str(nMean) + "+" + str(x)) except ZeroDivisionError: print("Error: Can't Divide by 0") except ValueError: print("Error: Check your 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
def sample_correlation(data, data1): try: mean1 = mean(data) mean2 = mean(data1) List1 = [] List2 = [] for num in data: a = subtraction(int(round(mean1, 0)), num) List1.append(a) for num in data1: b = subtraction(mean2, num) List2.append(b) c = np.multiply(List1, List2) cc = 0 for num in c: cc = cc + num d = 0 e = 0 # pprint(List1) # pprint(List2) for num in List1: d = d + square(num) for num in List2: e = e + square(num) f = multiplication(int(d), e) g = square_root(int(f)) h = division(int(g), cc) # pprint(float(cc)) # pprint(e) # pprint(f) # pprint(float(g)) # pprint(str(round(h,9))) nCorrelation = round(h, 9) # pprint(nCorrelation) return nCorrelation except ZeroDivisionError: print("Error - Cannot divide by 0") except ValueError: print("Error - Invalid data inputs")
def variance_pop_proportion(data): p = proportion(data) s = subtraction(p, 1) n = len(data) return division(multiplication(p, s), n)
def multiply(self, a, b): self.result = multiplication(a, b) return self.result
def multiply(self, a, b): ##Multiply Function## self.result = multiplication(a, b) return self.result
def test_multiplication(self): self.assertEqual(6, multiplication(2,3))
def margin(data, seed): zs = Z_Score.zscore(data, seed) sd = StandardDeviation.standard_deviance(data) margin = multiplication(zs, sd) return margin
def v_pop_proportion(lst): prob_will = proportion(lst) prob_wont = subtraction(prob_will, 1) result = multiplication(prob_wont, prob_will) vpp = division(result, len(lst)) return vpp
def var_pop_proportion(data): p = proportion(data) q = subtraction(1, p) n = len(data) return division(n, multiplication(p, q))
def confidence_interval_SUB(confidence_interval_SUB_list): return subtraction( population_mean(confidence_interval_SUB_list), (multiplication(zscore(confidence_interval_SUB_list)), division(population_standard_deviance(confidence_interval_SUB_list), square_root(num_values))))
def multiply(self, num1, num2): self.result = multiplication(num1, num2) return self.result
def variance_population_proportion(variance_population_proportion_list): return square_root(division(multiplication(subtraction(population_mean(variance_population_proportion_list), 1)), population_mean(variance_population_proportion_list), num_values))