def  _lowerCamelCase					(   ):
			return [list(range(10_00 - i						,			-10_00 - i						,			-1)) for i in range(10_00)]


A__           =							generate_large_matrix()
A__           =							(
    [[4, 3, 2, -1], [3, 2, 1, -1], [1, 1, -1, -2], [-1, -1, -2, -3]],
    [[3, 2], [1, 0]],
    [[7, 7, 6]],
    [[7, 7, 6], [-1, -2, -3]],
    grid,
)





def  _lowerCamelCase					(   a_				: list[list[int]]):
			assert all(row == sorted(a_						,			reverse=a_) for row in grid)
			assert all(list(a_) == sorted(a_						,			reverse=a_) for col in zip(*a_))





def  _lowerCamelCase					(   a_				: list[int]):
			lowerCamelCase						:Optional[Any]						  =     0
			lowerCamelCase						:Dict						  =     len(a_) - 1

			# Edge cases such as no values or all numbers are negative.
			if not array or array[0] < 0:
						return 0

			while right + 1 > left:
						lowerCamelCase						:str						  =     (left + right) // 2
						lowerCamelCase						:Optional[Any]						  =     array[mid]

						# Num must be negative and the index must be greater than or equal to 0.
						if num < 0 and array[mid - 1] >= 0:
									return mid

						if num >= 0:
									lowerCamelCase						:Any						  =     mid + 1
						else:
									lowerCamelCase						:int						  =     mid - 1
    # No negative numbers so return the last index of the array + 1 which is the length.
			return len(a_)





def  _lowerCamelCase					(   a_				: list[list[int]]):
			lowerCamelCase						:Dict						  =     0
			lowerCamelCase						:Optional[Any]						  =     len(grid[0])

			for i in range(len(a_)):
						lowerCamelCase						:str						  =     find_negative_index(grid[i][:bound])
						total += bound
			return (len(a_) * len(grid[0])) - total





def  _lowerCamelCase					(   a_				: list[list[int]]):
			return len([number for row in grid for number in row if number < 0])





def  _lowerCamelCase					(   a_				: list[list[int]]):
			lowerCamelCase						:Tuple						  =     0
			for row in grid:
						for i, number in enumerate(a_):
									if number < 0:
												total += len(a_) - i
												break
			return total





def  _lowerCamelCase					(   ):
			from timeit import timeit

			print('''Running benchmarks''')
			lowerCamelCase						:List[Any]						  =     (
			    '''from __main__ import count_negatives_binary_search, '''
			    '''count_negatives_brute_force, count_negatives_brute_force_with_break, grid'''
			)
			for func in (
			    "count_negatives_binary_search",  # took 0.7727 seconds
			    "count_negatives_brute_force_with_break",  # took 4.6505 seconds
			    "count_negatives_brute_force",  # took 12.8160 seconds
			):
						lowerCamelCase						:Optional[int]						  =     timeit(F"{func}(grid=grid)"						,			setup=a_						,			number=5_00)
						print(F"{func}() took {time:0.4f} seconds")


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			benchmark()




import numpy
class   _lowerCAmelCase		:







							def __init__(				self     :    Dict	,					__snake_case     :    numpy.ndarray	,					__snake_case     :    numpy.ndarray		):
										lowerCamelCase						:Dict						  =     input_array

										# Random initial weights are assigned where first argument is the
										# number of nodes in previous layer and second argument is the
										# number of nodes in the next layer.

										# Random initial weights are assigned.
										# self.input_array.shape[1] is used to represent number of nodes in input layer.
										# First hidden layer consists of 4 nodes.
										lowerCamelCase						:Dict						  =     numpy.random.rand(
										    self.input_array.shape[1]	,					4		)

										# Random initial values for the first hidden layer.
										# First hidden layer has 4 nodes.
										# Second hidden layer has 3 nodes.
										lowerCamelCase						:Dict						  =     numpy.random.rand(
										    4	,					3		)

										# Random initial values for the second hidden layer.
										# Second hidden layer has 3 nodes.
										# Output layer has 1 node.
										lowerCamelCase						:Any						  =     numpy.random.rand(3	,					1		)

										# Real output values provided.
										lowerCamelCase						:Union[str, Any]						  =     output_array

										# Predicted output values by the neural network.
										# Predicted_output array initially consists of zeroes.
										lowerCamelCase						:List[str]						  =     numpy.zeros(output_array.shape		)







							def 				snake_case  (				self     :    Optional[int]		):
										lowerCamelCase						:Any						  =     sigmoid(
										    numpy.dot(self.input_array	,					self.input_layer_and_first_hidden_layer_weights		)		)

										# layer_between_first_hidden_layer_and_second_hidden_layer is the layer
										# connecting the first hidden set of nodes with the second hidden set of nodes.
										lowerCamelCase						:Any						  =     sigmoid(
										    numpy.dot(
										        self.layer_between_input_and_first_hidden_layer	,					self.first_hidden_layer_and_second_hidden_layer_weights	,					)		)

										# layer_between_second_hidden_layer_and_output is the layer connecting
										# second hidden layer with the output node.
										lowerCamelCase						:Dict						  =     sigmoid(
										    numpy.dot(
										        self.layer_between_first_hidden_layer_and_second_hidden_layer	,					self.second_hidden_layer_and_output_layer_weights	,					)		)

										return self.layer_between_second_hidden_layer_and_output







							def 				snake_case  (				self     :    Any		):
										lowerCamelCase						:Union[str, Any]						  =     numpy.dot(
										    self.layer_between_first_hidden_layer_and_second_hidden_layer.T	,					2
										    * (self.output_array - self.predicted_output)
										    * sigmoid_derivative(self.predicted_output		)	,					)
										lowerCamelCase						:Dict						  =     numpy.dot(
										    self.layer_between_input_and_first_hidden_layer.T	,					numpy.dot(
										        2
										        * (self.output_array - self.predicted_output)
										        * sigmoid_derivative(self.predicted_output		)	,					self.second_hidden_layer_and_output_layer_weights.T	,					)
										    * sigmoid_derivative(
										        self.layer_between_first_hidden_layer_and_second_hidden_layer		)	,					)
										lowerCamelCase						:int						  =     numpy.dot(
										    self.input_array.T	,					numpy.dot(
										        numpy.dot(
										            2
										            * (self.output_array - self.predicted_output)
										            * sigmoid_derivative(self.predicted_output		)	,					self.second_hidden_layer_and_output_layer_weights.T	,					)
										        * sigmoid_derivative(
										            self.layer_between_first_hidden_layer_and_second_hidden_layer		)	,					self.first_hidden_layer_and_second_hidden_layer_weights.T	,					)
										    * sigmoid_derivative(self.layer_between_input_and_first_hidden_layer		)	,					)

										self.input_layer_and_first_hidden_layer_weights += (
										    updated_input_layer_and_first_hidden_layer_weights
										)
										self.first_hidden_layer_and_second_hidden_layer_weights += (
										    updated_first_hidden_layer_and_second_hidden_layer_weights
										)
										self.second_hidden_layer_and_output_layer_weights += (
										    updated_second_hidden_layer_and_output_layer_weights
										)







							def 				snake_case  (				self     :    Dict	,					__snake_case     :    numpy.ndarray	,					__snake_case     :    int	,					__snake_case     :    bool		):
										for iteration in range(1	,					iterations + 1		):
													lowerCamelCase						:Union[str, Any]						  =     self.feedforward()
													self.back_propagation()
													if give_loss:
																lowerCamelCase						:Tuple						  =     numpy.mean(numpy.square(output - self.feedforward()		)		)
																print(F"Iteration {iteration} Loss: {loss}"		)







							def 				snake_case  (				self     :    Optional[int]	,					__snake_case     :    numpy.ndarray		):
										lowerCamelCase						:int						  =     input_arr

										lowerCamelCase						:Union[str, Any]						  =     sigmoid(
										    numpy.dot(self.array	,					self.input_layer_and_first_hidden_layer_weights		)		)

										lowerCamelCase						:Optional[Any]						  =     sigmoid(
										    numpy.dot(
										        self.layer_between_input_and_first_hidden_layer	,					self.first_hidden_layer_and_second_hidden_layer_weights	,					)		)

										lowerCamelCase						:Optional[int]						  =     sigmoid(
										    numpy.dot(
										        self.layer_between_first_hidden_layer_and_second_hidden_layer	,					self.second_hidden_layer_and_output_layer_weights	,					)		)

										return int(self.layer_between_second_hidden_layer_and_output > 0.6		)





def  _lowerCamelCase					(   a_				: numpy.ndarray):
			return 1 / (1 + numpy.exp(-value))





def  _lowerCamelCase					(   a_				: numpy.ndarray):
			return (value) * (1 - (value))





def  _lowerCamelCase					(   ):
			lowerCamelCase						:Optional[Any]						  =     numpy.array(
			    (
			        [0, 0, 0],
			        [0, 0, 1],
			        [0, 1, 0],
			        [0, 1, 1],
			        [1, 0, 0],
			        [1, 0, 1],
			        [1, 1, 0],
			        [1, 1, 1],
			    )						,			dtype=numpy.floataa						,			)

			# True output values for the given input values.
			lowerCamelCase						:int						  =     numpy.array(([0], [1], [1], [0], [1], [0], [0], [1])						,			dtype=numpy.floataa)

			# Calling neural network class.
			lowerCamelCase						:List[Any]						  =     TwoHiddenLayerNeuralNetwork(
			    input_array=a_						,			output_array=a_)

			# Calling training function.
			# Set give_loss to True if you want to see loss in every iteration.
			neural_network.train(output=a_						,			iterations=10						,			give_loss=a_)

			return neural_network.predict(numpy.array(([1, 1, 1])						,			dtype=numpy.floataa))


if __name__ == "__main__":
			example()



