



"""simple docstring"""







from scipy.stats import spearmanr

import datasets


lowerCAmelCase__									="\nThe Spearman rank-order correlation coefficient is a measure of the\nrelationship between two datasets. Like other correlation coefficients,\nthis one varies between -1 and +1 with 0 implying no correlation.\nPositive correlations imply that as data in dataset x increases, so\ndoes data in dataset y. Negative correlations imply that as x increases,\ny decreases. Correlations of -1 or +1 imply an exact monotonic relationship.\n\nUnlike the Pearson correlation, the Spearman correlation does not\nassume that both datasets are normally distributed.\n\nThe p-value roughly indicates the probability of an uncorrelated system\nproducing datasets that have a Spearman correlation at least as extreme\nas the one computed from these datasets. The p-values are not entirely\nreliable but are probably reasonable for datasets larger than 500 or so.\n"

lowerCAmelCase__									="\nArgs:\n    predictions (`List[float]`): Predicted labels, as returned by a model.\n    references (`List[float]`): Ground truth labels.\n    return_pvalue (`bool`): If `True`, returns the p-value. If `False`, returns\n            only the spearmanr score. Defaults to `False`.\nReturns:\n    spearmanr (`float`): Spearman correlation coefficient.\n    p-value (`float`): p-value. **Note**: is only returned if `return_pvalue=True` is input.\nExamples:\n    Example 1:\n        >>> spearmanr_metric = datasets.load_metric(\"spearmanr\")\n        >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5], predictions=[10, 9, 2.5, 6, 4])\n        >>> print(results)\n        {'spearmanr': -0.7}\n\n    Example 2:\n        >>> spearmanr_metric = datasets.load_metric(\"spearmanr\")\n        >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5],\n        ...                                     predictions=[10, 9, 2.5, 6, 4],\n        ...                                     return_pvalue=True)\n        >>> print(results['spearmanr'])\n        -0.7\n        >>> print(round(results['spearmanr_pvalue'], 2))\n        0.19\n"

lowerCAmelCase__									=R"\\n@book{kokoska2000crc,\n  title={CRC standard probability and statistics tables and formulae},\n  author={Kokoska, Stephen and Zwillinger, Daniel},\n  year={2000},\n  publisher={Crc Press}\n}\n@article{2020SciPy-NMeth,\n  author  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and\n            Haberland, Matt and Reddy, Tyler and Cournapeau, David and\n            Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and\n            Bright, Jonathan and {van der Walt}, St{\'e}fan J. and\n            Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and\n            Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and\n            Kern, Robert and Larson, Eric and Carey, C J and\n            Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and\n            {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and\n            Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and\n            Harris, Charles R. and Archibald, Anne M. and\n            Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and\n            {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},\n  title   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific\n            Computing in Python}},\n  journal = {Nature Methods},\n  year    = {2020},\n  volume  = {17},\n  pages   = {261--272},\n  adsurl  = {https://rdcu.be/b08Wh},\n  doi     = {10.1038/s41592-019-0686-2},\n}\n"




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION       ,		_KWARGS_DESCRIPTION			)
class        A__(  datasets.Metric			):







      def  _a   (					self		:     int			)							->		Dict:






            """simple docstring"""

            return datasets.MetricInfo(
                description=_DESCRIPTION				,				citation=_CITATION				,				inputs_description=_KWARGS_DESCRIPTION				,				features=datasets.Features(
                    {
                        '''predictions''': datasets.Value('''float'''			),
                        '''references''': datasets.Value('''float'''			),
                    }			)				,				reference_urls=['''https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.spearmanr.html''']				,				)







      def  _a   (					self		:     Union[str, Any]				,				__SCREAMING_SNAKE_CASE		:     Optional[int]				,				__SCREAMING_SNAKE_CASE		:     int				,				__SCREAMING_SNAKE_CASE		:     List[Any]=False			)							->		str:






            """simple docstring"""

            __SCREAMING_SNAKE_CASE       		=   spearmanr(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE			)
            if return_pvalue:
                  return {"spearmanr": results[0], "spearmanr_pvalue": results[1]}
            else:
                  return {"spearmanr": results[0]}






from __future__ import annotations

from random import random
from typing import Generic, TypeVar

__UpperCamelCase   :			Any          = TypeVar("KT")
__UpperCamelCase   :			List[Any]          = TypeVar("VT")

class 						__lowerCAmelCase      (      Generic[KT, VT]					):
							def __init__(		self		:Union[str, Any]						, __magic_name__		:KT | str = "root"						, __magic_name__		:VT | None = None							):







								'''simple docstring'''







								a									=				key
								a									=				value
								a									=				[]
							def __repr__(		self		:List[Any]							):







								'''simple docstring'''







								return F'Node({self.key}: {self.value})'





							@property
							def  lowerCamelCase__				(		self		:List[str]							):







								'''simple docstring'''







								return len(self.forward							)







class 						__lowerCAmelCase      (      Generic[KT, VT]					):
							def __init__(		self		:Optional[Any]						, __magic_name__		:float = 0.5						, __magic_name__		:int = 16							):







								'''simple docstring'''







								a									=				Node[KT, VT]()
								a									=				0
								a									=				p
								a									=				max_level
							def __str__(		self		:Tuple							):







								'''simple docstring'''







								a									=				list(self							)

								if len(__magic_name__							) == 0:
									return F'SkipList(level={self.level})'

								a									=				max((len(str(__magic_name__							)							) for item in items)						, default=4							)
								a									=				max(__magic_name__						, 4							) + 4

								a									=				self.head
								a									=				[]

								a									=				node.forward.copy()
								lines.append(F'[{node.key}]'.ljust(__magic_name__						, """-"""							) + """* """ * len(__magic_name__							)							)
								lines.append(""" """ * label_size + """| """ * len(__magic_name__							)							)

								while len(node.forward							) != 0:
									a									=				node.forward[0]

									lines.append(
									    F'[{node.key}]'.ljust(__magic_name__						, """-"""							)
									    + """ """.join(str(n.key							) if n.key == node.key else """|""" for n in forwards							)							)
									lines.append(""" """ * label_size + """| """ * len(__magic_name__							)							)
									a									=				node.forward

								lines.append("""None""".ljust(__magic_name__							) + """* """ * len(__magic_name__							)							)
								return F'SkipList(level={self.level})\n' + "\n".join(__magic_name__							)
							def __iter__(		self		:int							):







								'''simple docstring'''







								a									=				self.head

								while len(node.forward							) != 0:
									yield node.forward[0].key
									a									=				node.forward[0]
							def  lowerCamelCase__				(		self		:int							):







								'''simple docstring'''







								a									=				1
								while random() < self.p and level < self.max_level:
									level += 1

								return level
							def  lowerCamelCase__				(		self		:Dict						, __magic_name__		:int							):







								'''simple docstring'''







								a									=				[]

								a									=				self.head

								for i in reversed(range(self.level							)							):
									# i < node.level - When node level is lesser than `i` decrement `i`.
									# node.forward[i].key < key - Jumping to node with key value higher
									#                             or equal to searched key would result
									#                             in skipping searched key.
									while i < node.level and node.forward[i].key < key:
										a									=				node.forward[i]
									# Each leftmost node (relative to searched node) will potentially have to
									# be updated.
									update_vector.append(__magic_name__							)

								update_vector.reverse()  # Note that we were inserting values in reverse order.

								# len(node.forward) != 0 - If current node doesn't contain any further
								#                          references then searched key is not present.
								# node.forward[0].key == key - Next node key should be equal to search key
								#                              if key is present.
								if len(node.forward							) != 0 and node.forward[0].key == key:
									return node.forward[0], update_vector
								else:
									return None, update_vector
							def  lowerCamelCase__				(		self		:List[str]						, __magic_name__		:KT							):







								'''simple docstring'''







								a							,					a									=				self._locate_node(__magic_name__							)

								if node is not None:
									for i, update_node in enumerate(__magic_name__							):
										# Remove or replace all references to removed node.
										if update_node.level > i and update_node.forward[i].key == key:
											if node.level > i:
												a									=				node.forward[i]
											else:
												a									=				update_node.forward[:i]
							def  lowerCamelCase__				(		self		:List[str]						, __magic_name__		:KT						, __magic_name__		:VT							):







								'''simple docstring'''







								a							,					a									=				self._locate_node(__magic_name__							)
								if node is not None:
									a									=				value
								else:
									a									=				self.random_level()

									if level > self.level:
										# After level increase we have to add additional nodes to head.
										for _ in range(self.level - 1						, __magic_name__							):
											update_vector.append(self.head							)
										a									=				level

									a									=				Node(__magic_name__						, __magic_name__							)

									for i, update_node in enumerate(update_vector[:level]							):
										# Change references to pass through new node.
										if update_node.level > i:
											new_node.forward.append(update_node.forward[i]							)

										if update_node.level < i + 1:
											update_node.forward.append(__magic_name__							)
										else:
											a									=				new_node





							def  lowerCamelCase__				(		self		:Dict						, __magic_name__		:VT							):







								'''simple docstring'''







								a							,					a									=				self._locate_node(__magic_name__							)

								if node is not None:
									return node.value

								return None







def 						__A						(      ) ->			Tuple:
	a									=				SkipList()
	skip_list.insert("""Key1"""				,     3       )
	skip_list.insert("""Key2"""				,     12       )
	skip_list.insert("""Key3"""				,     41       )
	skip_list.insert("""Key4"""				,     -19       )

	a									=				skip_list.head
	a									=				{}
	while node.level != 0:
		a									=				node.forward[0]
		a									=				node.value

	assert len(__lowerCamelCase       ) == 4
	assert all_values["Key1"] == 3
	assert all_values["Key2"] == 12
	assert all_values["Key3"] == 41
	assert all_values["Key4"] == -19





def 						__A						(      ) ->			Tuple:
	a									=				SkipList()
	skip_list.insert("""Key1"""				,     10       )
	skip_list.insert("""Key1"""				,     12       )

	skip_list.insert("""Key5"""				,     7       )
	skip_list.insert("""Key7"""				,     10       )
	skip_list.insert("""Key10"""				,     5       )

	skip_list.insert("""Key7"""				,     7       )
	skip_list.insert("""Key5"""				,     5       )
	skip_list.insert("""Key10"""				,     10       )

	a									=				skip_list.head
	a									=				{}
	while node.level != 0:
		a									=				node.forward[0]
		a									=				node.value

	if len(__lowerCamelCase       ) != 4:
		print()
	assert len(__lowerCamelCase       ) == 4
	assert all_values["Key1"] == 12
	assert all_values["Key7"] == 7
	assert all_values["Key5"] == 5
	assert all_values["Key10"] == 10





def 						__A						(      ) ->			Optional[int]:
	a									=				SkipList()
	assert skip_list.find("""Some key"""       ) is None





def 						__A						(      ) ->			Optional[int]:
	a									=				SkipList()

	skip_list.insert("""Key2"""				,     20       )
	assert skip_list.find("""Key2"""       ) == 20

	skip_list.insert("""Some Key"""				,     10       )
	skip_list.insert("""Key2"""				,     8       )
	skip_list.insert("""V"""				,     13       )

	assert skip_list.find("""Y"""       ) is None
	assert skip_list.find("""Key2"""       ) == 8
	assert skip_list.find("""Some Key"""       ) == 10
	assert skip_list.find("""V"""       ) == 13





def 						__A						(      ) ->			str:
	a									=				SkipList()
	skip_list.delete("""Some key"""       )

	assert len(skip_list.head.forward       ) == 0





def 						__A						(      ) ->			int:
	a									=				SkipList()

	skip_list.insert("""Key1"""				,     12       )
	skip_list.insert("""V"""				,     13       )
	skip_list.insert("""X"""				,     14       )
	skip_list.insert("""Key2"""				,     15       )

	skip_list.delete("""V"""       )
	skip_list.delete("""Key2"""       )

	assert skip_list.find("""V"""       ) is None
	assert skip_list.find("""Key2"""       ) is None





def 						__A						(      ) ->			Union[str, Any]:
	a									=				SkipList()

	skip_list.insert("""Key1"""				,     12       )
	skip_list.insert("""V"""				,     13       )
	skip_list.insert("""X"""				,     14       )
	skip_list.insert("""Key2"""				,     15       )

	skip_list.delete("""V"""       )
	assert skip_list.find("""V"""       ) is None
	assert skip_list.find("""X"""       ) == 14
	assert skip_list.find("""Key1"""       ) == 12
	assert skip_list.find("""Key2"""       ) == 15

	skip_list.delete("""X"""       )
	assert skip_list.find("""V"""       ) is None
	assert skip_list.find("""X"""       ) is None
	assert skip_list.find("""Key1"""       ) == 12
	assert skip_list.find("""Key2"""       ) == 15

	skip_list.delete("""Key1"""       )
	assert skip_list.find("""V"""       ) is None
	assert skip_list.find("""X"""       ) is None
	assert skip_list.find("""Key1"""       ) is None
	assert skip_list.find("""Key2"""       ) == 15

	skip_list.delete("""Key2"""       )
	assert skip_list.find("""V"""       ) is None
	assert skip_list.find("""X"""       ) is None
	assert skip_list.find("""Key1"""       ) is None
	assert skip_list.find("""Key2"""       ) is None





def 						__A						(      ) ->			Dict:
	a									=				SkipList()

	skip_list.insert("""Key1"""				,     12       )
	skip_list.insert("""V"""				,     13       )
	skip_list.insert("""X"""				,     142       )
	skip_list.insert("""Key2"""				,     15       )

	skip_list.delete("""X"""       )

	def traverse_keys(__lowerCamelCase       ):
		yield node.key
		for forward_node in node.forward:
			yield from traverse_keys(__lowerCamelCase       )

	assert len(set(traverse_keys(skip_list.head       )       )       ) == 4





def 						__A						(      ) ->			Optional[Any]:
	def is_sorted(__lowerCamelCase       ):
		return all(next_item >= item for item, next_item in zip(__lowerCamelCase				,     lst[1:]       )       )

	a									=				SkipList()
	for i in range(10       ):
		skip_list.insert(__lowerCamelCase				,     __lowerCamelCase       )
	assert is_sorted(list(__lowerCamelCase       )       )
	skip_list.delete(5       )
	skip_list.delete(8       )
	skip_list.delete(2       )
	assert is_sorted(list(__lowerCamelCase       )       )
	skip_list.insert(-12				,     -12       )
	skip_list.insert(77				,     77       )
	assert is_sorted(list(__lowerCamelCase       )       )





def 						__A						(      ) ->			Optional[Any]:
	for _ in range(100       ):
		# Repeat test 100 times due to the probabilistic nature of skip list
		# random values == random bugs
		test_insert()
		test_insert_overrides_existing_value()

		test_searching_empty_list_returns_none()
		test_search()

		test_deleting_item_from_empty_list_do_nothing()
		test_deleted_items_are_not_founded_by_find_method()
		test_delete_removes_only_given_key()
		test_delete_doesnt_leave_dead_nodes()

		test_iter_always_yields_sorted_values()





def 						__A						(      ) ->			Optional[int]:
	a									=				SkipList()
	skip_list.insert(2				,     """2"""       )
	skip_list.insert(4				,     """4"""       )
	skip_list.insert(6				,     """4"""       )
	skip_list.insert(4				,     """5"""       )
	skip_list.insert(8				,     """4"""       )
	skip_list.insert(9				,     """4"""       )

	skip_list.delete(4       )

	print(__lowerCamelCase       )


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		main()

