



'''simple docstring'''




import numpy as np
from scipy.spatial.distance import cdist
from sklearn.metrics import fa_score

import datasets


lowerCamelCase							:Optional[int]       = '''\
    @inproceedings{kakwani2020indicnlpsuite,
    title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},
    author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},
    year={2020},
    booktitle={Findings of EMNLP},
}
'''

lowerCamelCase							:Tuple       = '''\
    IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide
    variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.
'''

lowerCamelCase							:str       = '''
Compute IndicGLUE evaluation metric associated to each IndicGLUE dataset.
Args:
    predictions: list of predictions to score (as int64),
        except for \'cvit-mkb-clsr\' where each prediction is a vector (of float32).
    references: list of ground truth labels corresponding to the predictions (as int64),
        except for \'cvit-mkb-clsr\' where each reference is a vector (of float32).
Returns: depending on the IndicGLUE subset, one or several of:
    "accuracy": Accuracy
    "f1": F1 score
    "precision": Precision@10
Examples:

    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wnli\')  # \'wnli\' or any of ["copa", "sna", "csqa", "wstp", "inltkh", "bbca", "iitp-mr", "iitp-pr", "actsa-sc", "md"]
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0}

    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wiki-ner\')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0, \'f1\': 1.0}

    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'cvit-mkb-clsr\')
    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]
    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]
    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'precision@10\': 1.0}

'''



def      a      (			lowerCamelCase__						,				lowerCamelCase__   ):
			'''simple docstring'''





			return float((preds == labels).mean()   )



def      a      (			lowerCamelCase__						,				lowerCamelCase__   ):
			'''simple docstring'''





			A_     :						List[Any]     =					simple_accuracy(lowerCamelCase__						,				lowerCamelCase__   )
			A_     :						Union[str, Any]     =					float(fa_score(y_true=lowerCamelCase__						,				y_pred=lowerCamelCase__   )   )
			return {
			    "accuracy": acc,
			    "f1": fa,
			}



def      a      (			lowerCamelCase__						,				lowerCamelCase__   ):
			'''simple docstring'''





			A_     :						Any     =					np.array(lowerCamelCase__   )
			A_     :						List[str]     =					np.array(lowerCamelCase__   )
			A_     :						Tuple     =					en_sentvecs.shape[0]

			# mean centering
			A_     :						Tuple     =					en_sentvecs - np.mean(lowerCamelCase__						,				axis=0   )
			A_     :						Tuple     =					in_sentvecs - np.mean(lowerCamelCase__						,				axis=0   )

			A_     :						int     =					cdist(lowerCamelCase__						,				lowerCamelCase__						,				"""cosine"""   )
			A_     :						str     =					np.array(range(lowerCamelCase__   )   )
			A_     :						List[Any]     =					sim.argsort(axis=1   )[:, :10]
			A_     :						List[Any]     =					np.any(preds == actual[:, None]						,				axis=1   )
			return float(matches.mean()   )







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


	def    _a     (self							):
				if self.config_name not in [
				    "wnli",
				    "copa",
				    "sna",
				    "csqa",
				    "wstp",
				    "inltkh",
				    "bbca",
				    "cvit-mkb-clsr",
				    "iitp-mr",
				    "iitp-pr",
				    "actsa-sc",
				    "md",
				    "wiki-ner",
				]:
							raise KeyError(
							    """You should supply a configuration name selected in """
							    """[\"wnli\", \"copa\", \"sna\", \"csqa\", \"wstp\", \"inltkh\", \"bbca\", """
							    """\"cvit-mkb-clsr\", \"iitp-mr\", \"iitp-pr\", \"actsa-sc\", \"md\", """
							    """\"wiki-ner\"]"""							)
				return datasets.MetricInfo(
				    description=_DESCRIPTION	,				citation=_CITATION	,				inputs_description=_KWARGS_DESCRIPTION	,				features=datasets.Features(
				        {
				            """predictions""": datasets.Value("""int64"""							)
				            if self.config_name != """cvit-mkb-clsr"""
				            else datasets.Sequence(datasets.Value("""float32"""							)							),
				            """references""": datasets.Value("""int64"""							)
				            if self.config_name != """cvit-mkb-clsr"""
				            else datasets.Sequence(datasets.Value("""float32"""							)							),
				        }							)	,				codebase_urls=[]	,				reference_urls=[]	,				format="""numpy""" if self.config_name != """cvit-mkb-clsr""" else None	,				)


	def    _a     (self	,				lowercase	,				lowercase							):
				if self.config_name == "cvit-mkb-clsr":
							return {"precision@10": precision_at_aa(lowercase	,				lowercase							)}
				elif self.config_name in ["wiki-ner"]:
							return acc_and_fa(lowercase	,				lowercase							)
				elif self.config_name in [
				    "wnli",
				    "copa",
				    "sna",
				    "csqa",
				    "wstp",
				    "inltkh",
				    "bbca",
				    "iitp-mr",
				    "iitp-pr",
				    "actsa-sc",
				    "md",
				]:
							return {"accuracy": simple_accuracy(lowercase	,				lowercase							)}
				else:
							raise KeyError(
							    """You should supply a configuration name selected in """
							    """[\"wnli\", \"copa\", \"sna\", \"csqa\", \"wstp\", \"inltkh\", \"bbca\", """
							    """\"cvit-mkb-clsr\", \"iitp-mr\", \"iitp-pr\", \"actsa-sc\", \"md\", """
							    """\"wiki-ner\"]"""							)




'''simple docstring'''




from __future__ import annotations

from functools import lru_cache
from math import ceil

lowerCamelCase							:List[str]       = 1_0_0

lowerCamelCase							:Dict       = set(range(3, NUM_PRIMES, 2))
primes.add(2)
lowerCamelCase							:int

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
						if prime not in primes:
												continue
						primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))



@lru_cache(maxsize=1_00   )
def      a      (			lowerCamelCase__   ):
			'''simple docstring'''





			if number_to_partition < 0:
						return set()
			elif number_to_partition == 0:
						return {1}

			A_     :						set[int]     =					set()
			A_     :						int
			A_     :						int

			for prime in primes:
						if prime > number_to_partition:
									continue
						for sub in partition(number_to_partition - prime   ):
									ret.add(sub * prime   )

			return ret



def      a      (			lowerCamelCase__ = 50_00   ):
			'''simple docstring'''





			for number_to_partition in range(1						,				lowerCamelCase__   ):
						if len(partition(lowerCamelCase__   )   ) > number_unique_partitions:
									return number_to_partition
			return None


if __name__ == "__main__":
						print(F"{solution() = }")