


"""simple docstring"""


def _lowerCamelCase	(		_UpperCamelCase      ):

			'''simple docstring'''




			__lowerCAmelCase				    =			generate_pascal_triangle(_UpperCamelCase      )
			for row_idx in range(_UpperCamelCase      ):
						# Print left spaces
						for _ in range(num_rows - row_idx - 1      ):
									print(end=" "      )
						# Print row values
						for col_idx in range(row_idx + 1      ):
									if col_idx != row_idx:
												print(triangle[row_idx][col_idx]    , end=" "      )
									else:
												print(triangle[row_idx][col_idx]    , end=""      )
						print()


def _lowerCamelCase	(		_UpperCamelCase      ):

			'''simple docstring'''




			if not isinstance(_UpperCamelCase    , _UpperCamelCase      ):
						raise TypeError("The input value of 'num_rows' should be 'int'"      )

			if num_rows == 0:
						return []
			elif num_rows < 0:
						raise ValueError(
						    "The input value of 'num_rows' should be greater than or equal to 0"      )

			__lowerCAmelCase				    =			[]
			for current_row_idx in range(_UpperCamelCase      ):
						__lowerCAmelCase				    =			populate_current_row(_UpperCamelCase    , _UpperCamelCase      )
						triangle.append(_UpperCamelCase      )
			return triangle


def _lowerCamelCase	(		_UpperCamelCase    , _UpperCamelCase      ):

			'''simple docstring'''




			__lowerCAmelCase				    =			[-1] * (current_row_idx + 1)
			# first and last elements of current row are equal to 1
			__lowerCAmelCase    ,	__lowerCAmelCase				    =			1, 1
			for current_col_idx in range(1    , _UpperCamelCase      ):
						calculate_current_element(
						    _UpperCamelCase    , _UpperCamelCase    , _UpperCamelCase    , _UpperCamelCase      )
			return current_row


def _lowerCamelCase	(		_UpperCamelCase    , _UpperCamelCase    , _UpperCamelCase    , _UpperCamelCase    , ):

			'''simple docstring'''




			__lowerCAmelCase				    =			triangle[current_row_idx - 1][current_col_idx - 1]
			__lowerCAmelCase				    =			triangle[current_row_idx - 1][current_col_idx]
			__lowerCAmelCase				    =			above_to_left_elt + above_to_right_elt


def _lowerCamelCase	(		_UpperCamelCase      ):

			'''simple docstring'''




			if not isinstance(_UpperCamelCase    , _UpperCamelCase      ):
						raise TypeError("The input value of 'num_rows' should be 'int'"      )

			if num_rows == 0:
						return []
			elif num_rows < 0:
						raise ValueError(
						    "The input value of 'num_rows' should be greater than or equal to 0"      )

			__lowerCAmelCase				    =			[[1]]

			for row_index in range(1    , _UpperCamelCase      ):
						__lowerCAmelCase				    =			[0] + result[-1] + [0]
						__lowerCAmelCase				    =			row_index + 1
						# Calculate the number of distinct elements in a row
						__lowerCAmelCase				    =			sum(divmod(_UpperCamelCase    , 2      )      )
						__lowerCAmelCase				    =			[
						    temp_row[i - 1] + temp_row[i] for i in range(1    , distinct_elements + 1      )
						]
						__lowerCAmelCase				    =			row_first_half[: (row_index + 1) // 2]
						row_second_half.reverse()
						__lowerCAmelCase				    =			row_first_half + row_second_half
						result.append(_UpperCamelCase      )

			return result


def _lowerCamelCase	(		):

			'''simple docstring'''




			from collections.abc import Callable
			from timeit import timeit

			def benchmark_a_function(_UpperCamelCase    , _UpperCamelCase      ) -> None:
						__lowerCAmelCase				    =			f"{func.__name__}({value})"
						__lowerCAmelCase				    =			timeit(f"__main__.{call}"    , setup="import __main__"      )
						# print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
						print(f"{call:38} -- {timing:.4f} seconds"      )

			for value in range(15      ):  # (1, 7, 14):
						for func in (generate_pascal_triangle, generate_pascal_triangle_optimized):
									benchmark_a_function(_UpperCamelCase    , _UpperCamelCase      )
						print()


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	benchmark()








"""simple docstring"""


import numpy

# List of input, output pairs
A     :   Any			    =			(
    ((5, 2, 3), 1_5),
    ((6, 5, 9), 2_5),
    ((1_1, 1_2, 1_3), 4_1),
    ((1, 1, 1), 8),
    ((1_1, 1_2, 1_3), 4_1),
)
A     :   str			    =			(((5_1_5, 2_2, 1_3), 5_5_5), ((6_1, 3_5, 4_9), 1_5_0))
A     :   Union[str, Any]			    =			[2, 4, 1, 5]
A     :   int			    =			len(train_data)
A     :   Dict			    =			0.009


def _lowerCamelCase	(		_UpperCamelCase    , _UpperCamelCase="train"      ):

			'''simple docstring'''




			return calculate_hypothesis_value(_UpperCamelCase    , _UpperCamelCase      ) - output(
			    _UpperCamelCase    , _UpperCamelCase      )


def _lowerCamelCase	(		_UpperCamelCase      ):

			'''simple docstring'''




			__lowerCAmelCase				    =			0
			for i in range(len(_UpperCamelCase      ) - 1      ):
						hyp_val += data_input_tuple[i] * parameter_vector[i + 1]
			hyp_val += parameter_vector[0]
			return hyp_val


def _lowerCamelCase	(		_UpperCamelCase    , _UpperCamelCase      ):

			'''simple docstring'''




			if data_set == "train":
						return train_data[example_no][1]
			elif data_set == "test":
						return test_data[example_no][1]
			return None


def _lowerCamelCase	(		_UpperCamelCase    , _UpperCamelCase      ):

			'''simple docstring'''




			if data_set == "train":
						return _hypothesis_value(train_data[example_no][0]      )
			elif data_set == "test":
						return _hypothesis_value(test_data[example_no][0]      )
			return None


def _lowerCamelCase	(		_UpperCamelCase    , _UpperCamelCase=m      ):

			'''simple docstring'''




			__lowerCAmelCase				    =			0
			for i in range(_UpperCamelCase      ):
						if index == -1:
									summation_value += _error(_UpperCamelCase      )
						else:
									summation_value += _error(_UpperCamelCase      ) * train_data[i][0][index]
			return summation_value


def _lowerCamelCase	(		_UpperCamelCase      ):

			'''simple docstring'''




			__lowerCAmelCase				    =			summation_of_cost_derivative(_UpperCamelCase    , _UpperCamelCase      ) / m
			return cost_derivative_value


def _lowerCamelCase	(		):

			'''simple docstring'''




			global parameter_vector
			# Tune these values to set a tolerance value for predicted output
			__lowerCAmelCase				    =			0.00_00_02
			__lowerCAmelCase				    =			0
			__lowerCAmelCase				    =			0
			while True:
						j += 1
						__lowerCAmelCase				    =			[0, 0, 0, 0]
						for i in range(0    , len(_UpperCamelCase      )      ):
									__lowerCAmelCase				    =			get_cost_derivative(i - 1      )
									__lowerCAmelCase				    =			(
									    parameter_vector[i] - LEARNING_RATE * cost_derivative
									)
						if numpy.allclose(
						    _UpperCamelCase    , _UpperCamelCase    , atol=_UpperCamelCase    , rtol=_UpperCamelCase    , ):
									break
						__lowerCAmelCase				    =			temp_parameter_vector
			print(("Number of iterations:", j)      )


def _lowerCamelCase	(		):

			'''simple docstring'''




			for i in range(len(_UpperCamelCase      )      ):
						print(("Actual output value:", output(_UpperCamelCase    , "test"      ))      )
						print(("Hypothesis output:", calculate_hypothesis_value(_UpperCamelCase    , "test"      ))      )


if __name__ == "__main__":
	run_gradient_descent()
	print("\nTesting gradient descent for a linear hypothesis function.\n")
	test_gradient_descent()




