"""simple docstring"""







import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


SCREAMING_SNAKE_CASE									=						version.parse(importlib_metadata.version('nltk'))
if NLTK_VERSION >= version.Version('3.6.4'):
						from nltk import word_tokenize


SCREAMING_SNAKE_CASE									=						'\\n@inproceedings{banarjee2005,\n  title     = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n  author    = {Banerjee, Satanjeev  and Lavie, Alon},\n  booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n  month     = jun,\n  year      = {2005},\n  address   = {Ann Arbor, Michigan},\n  publisher = {Association for Computational Linguistics},\n  url       = {https://www.aclweb.org/anthology/W05-0909},\n  pages     = {65--72},\n}\n'

SCREAMING_SNAKE_CASE									=						'\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n'

SCREAMING_SNAKE_CASE									=						'\nComputes METEOR score of translated segments against one or more references.\nArgs:\n    predictions: list of predictions to score. Each prediction\n        should be a string with tokens separated by spaces.\n    references: list of reference for each prediction. Each\n        reference should be a string with tokens separated by spaces.\n    alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n    beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n    gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n    \'meteor\': meteor score.\nExamples:\n\n    >>> meteor = datasets.load_metric(\'meteor\')\n    >>> predictions = ["It is a guide to action which ensures that the military always obeys the commands of the party"]\n    >>> references = ["It is a guide to action that ensures that the military will forever heed Party commands"]\n    >>> results = meteor.compute(predictions=predictions, references=references)\n    >>> print(round(results["meteor"], 4))\n    0.6944\n'



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







				def 							__UpperCAmelCase					( self    :       Union[str, Any]						):

					"""simple docstring"""






					return datasets.MetricInfo(
					    description=_DESCRIPTION			,					citation=_CITATION			,					inputs_description=_KWARGS_DESCRIPTION			,					features=datasets.Features(
					        {
					            'predictions': datasets.Value('string'			,					id='sequence'						),
					            'references': datasets.Value('string'			,					id='sequence'						),
					        }						)			,					codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py']			,					reference_urls=[
					        'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score',
					        'https://en.wikipedia.org/wiki/METEOR',
					    ]			,					)







				def 							__UpperCAmelCase					( self    :       str			,					lowerCamelCase_    :       str						):

					"""simple docstring"""






					import nltk

					nltk.download('wordnet'						)
					if NLTK_VERSION >= version.Version('3.6.5'						):
						nltk.download('punkt'						)
					if NLTK_VERSION >= version.Version('3.6.6'						):
						nltk.download('omw-1.4'						)







				def 							__UpperCAmelCase					( self    :       Tuple			,					lowerCamelCase_    :       List[Any]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int=0.9			,					lowerCamelCase_    :       List[str]=3			,					lowerCamelCase_    :       Tuple=0.5						):

					"""simple docstring"""






					if NLTK_VERSION >= version.Version('3.6.5'						):
						_lowercase :    Tuple							=							[
						    meteor_score.single_meteor_score(
						        word_tokenize(lowerCamelCase_						)			,					word_tokenize(lowerCamelCase_						)			,					alpha=lowerCamelCase_			,					beta=lowerCamelCase_			,					gamma=lowerCamelCase_						)
						    for ref, pred in zip(lowerCamelCase_			,					lowerCamelCase_						)
						]
					else:
						_lowercase :    Union[str, Any]							=							[
						    meteor_score.single_meteor_score(lowerCamelCase_			,					lowerCamelCase_			,					alpha=lowerCamelCase_			,					beta=lowerCamelCase_			,					gamma=lowerCamelCase_						)
						    for ref, pred in zip(lowerCamelCase_			,					lowerCamelCase_						)
						]

					return {"meteor": np.mean(lowerCamelCase_						)}




"""simple docstring"""







from __future__ import annotations

import math
import random
from collections.abc import Collection
from typing import overload



class  _lowerCamelCase			:







				def __init__( self    :       str			,					lowerCamelCase_    :       Collection[float] | None = None						):

					"""simple docstring"""






					if components is None:
						_lowercase :    Any							=							[]
					_lowercase :    int							=							list(lowerCamelCase_						)







				def __len__( self    :       int						):

					"""simple docstring"""






					return len(self.__components						)







				def __str__( self    :       List[Any]						):

					"""simple docstring"""






					return "(" + ",".join(map(lowerCamelCase_			,					self.__components						)						) + ")"







				def __add__( self    :       Dict			,					lowerCamelCase_    :       Vector						):

					"""simple docstring"""






					_lowercase :    Union[str, Any]							=							len(self						)
					if size == len(lowerCamelCase_						):
						_lowercase :    int							=							[self.__components[i] + other.component(lowerCamelCase_						) for i in range(lowerCamelCase_						)]
						return Vector(lowerCamelCase_						)
					else:
						raise Exception('must have the same size'						)







				def __sub__( self    :       int			,					lowerCamelCase_    :       Vector						):

					"""simple docstring"""






					_lowercase :    Optional[int]							=							len(self						)
					if size == len(lowerCamelCase_						):
						_lowercase :    Optional[int]							=							[self.__components[i] - other.component(lowerCamelCase_						) for i in range(lowerCamelCase_						)]
						return Vector(lowerCamelCase_						)
					else:  # error case
						raise Exception('must have the same size'						)







				@overload
				def __mul__( self    :       Tuple			,					lowerCamelCase_    :       float						):

					"""simple docstring"""






					...







				@overload
				def __mul__( self    :       Tuple			,					lowerCamelCase_    :       Vector						):

					"""simple docstring"""






					...







				def __mul__( self    :       int			,					lowerCamelCase_    :       float | Vector						):

					"""simple docstring"""






					if isinstance(lowerCamelCase_			,					(float, int)						):
						_lowercase :    List[Any]							=							[c * other for c in self.__components]
						return Vector(lowerCamelCase_						)
					elif isinstance(lowerCamelCase_			,					lowerCamelCase_						) and len(self						) == len(lowerCamelCase_						):
						_lowercase :    Any							=							len(self						)
						_lowercase :    List[Any]							=							[self.__components[i] * other.component(lowerCamelCase_						) for i in range(lowerCamelCase_						)]
						return sum(lowerCamelCase_						)
					else:  # error case
						raise Exception('invalid operand!'						)







				def 							__UpperCAmelCase					( self    :       Dict						):

					"""simple docstring"""






					return Vector(self.__components						)







				def 							__UpperCAmelCase					( self    :       List[str]			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					if isinstance(lowerCamelCase_			,					lowerCamelCase_						) and -len(self.__components						) <= i < len(self.__components						):
						return self.__components[i]
					else:
						raise Exception('index out of range'						)







				def 							__UpperCAmelCase					( self    :       str			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       float						):

					"""simple docstring"""






					assert -len(self.__components						) <= pos < len(self.__components						)
					_lowercase :    Tuple							=							value







				def 							__UpperCAmelCase					( self    :       List[Any]						):

					"""simple docstring"""






					if len(self.__components						) == 0:
						raise Exception('Vector is empty'						)
					_lowercase :    Optional[int]							=							[c**2 for c in self.__components]
					return math.sqrt(sum(lowerCamelCase_						)						)







				def 							__UpperCAmelCase					( self    :       int			,					lowerCamelCase_    :       Vector			,					lowerCamelCase_    :       bool = False						):

					"""simple docstring"""






					_lowercase :    int							=							self * other
					_lowercase :    Any							=							self.euclidean_length() * other.euclidean_length()
					if deg:
						return math.degrees(math.acos(num / den						)						)
					else:
						return math.acos(num / den						)



def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	assert isinstance(__UpperCAmelCase     ,__UpperCAmelCase			)
	return Vector([0] * dimension			)


def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase			):






	"""simple docstring"""





	assert isinstance(__UpperCAmelCase     ,__UpperCAmelCase			) and (isinstance(__UpperCAmelCase     ,__UpperCAmelCase			))
	_lowercase :    str							=							[0] * dimension
	_lowercase :    List[Any]							=							1
	return Vector(__UpperCAmelCase			)


def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase			):






	"""simple docstring"""





	assert (
	    isinstance(__UpperCAmelCase     ,__UpperCAmelCase			)
	    and isinstance(__UpperCAmelCase     ,__UpperCAmelCase			)
	    and (isinstance(__UpperCAmelCase     ,(int, float)			))
	)
	return x * scalar + y


def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase			):






	"""simple docstring"""





	random.seed(__UpperCAmelCase			)
	_lowercase :    Tuple							=							[random.randint(__UpperCAmelCase     ,__UpperCAmelCase			) for _ in range(__UpperCAmelCase			)]
	return Vector(__UpperCAmelCase			)



class  _lowerCamelCase			:







				def __init__( self    :       Dict			,					lowerCamelCase_    :       list[list[float]]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					_lowercase :    Tuple							=							matrix
					_lowercase :    str							=							w
					_lowercase :    Tuple							=							h







				def __str__( self    :       int						):

					"""simple docstring"""






					_lowercase :    Tuple							=							''
					for i in range(self.__height						):
						ans += "|"
						for j in range(self.__width						):
							if j < self.__width - 1:
								ans += str(self.__matrix[i][j]						) + ","
							else:
								ans += str(self.__matrix[i][j]						) + "|\n"
					return ans







				def __add__( self    :       Dict			,					lowerCamelCase_    :       Matrix						):

					"""simple docstring"""






					if self.__width == other.width() and self.__height == other.height():
						_lowercase :    Dict							=							[]
						for i in range(self.__height						):
							_lowercase :    Tuple							=							[
							    self.__matrix[i][j] + other.component(lowerCamelCase_			,					lowerCamelCase_						)
							    for j in range(self.__width						)
							]
							matrix.append(lowerCamelCase_						)
						return Matrix(lowerCamelCase_			,					self.__width			,					self.__height						)
					else:
						raise Exception('matrix must have the same dimension!'						)







				def __sub__( self    :       str			,					lowerCamelCase_    :       Matrix						):

					"""simple docstring"""






					if self.__width == other.width() and self.__height == other.height():
						_lowercase :    List[Any]							=							[]
						for i in range(self.__height						):
							_lowercase :    int							=							[
							    self.__matrix[i][j] - other.component(lowerCamelCase_			,					lowerCamelCase_						)
							    for j in range(self.__width						)
							]
							matrix.append(lowerCamelCase_						)
						return Matrix(lowerCamelCase_			,					self.__width			,					self.__height						)
					else:
						raise Exception('matrices must have the same dimension!'						)







				@overload
				def __mul__( self    :       Union[str, Any]			,					lowerCamelCase_    :       float						):

					"""simple docstring"""






					...







				@overload
				def __mul__( self    :       List[str]			,					lowerCamelCase_    :       Vector						):

					"""simple docstring"""






					...







				def __mul__( self    :       int			,					lowerCamelCase_    :       float | Vector						):

					"""simple docstring"""






					if isinstance(lowerCamelCase_			,					lowerCamelCase_						):  # matrix-vector
						if len(lowerCamelCase_						) == self.__width:
							_lowercase :    Optional[int]							=							zero_vector(self.__height						)
							for i in range(self.__height						):
								_lowercase :    Optional[Any]							=							[
								    self.__matrix[i][j] * other.component(lowerCamelCase_						)
								    for j in range(self.__width						)
								]
								ans.change_component(lowerCamelCase_			,					sum(lowerCamelCase_						)						)
							return ans
						else:
							raise Exception(
							    'vector must have the same size as the '
							    'number of columns of the matrix!'						)
					elif isinstance(lowerCamelCase_			,					(int, float)						):  # matrix-scalar
						_lowercase :    Optional[int]							=							[
						    [self.__matrix[i][j] * other for j in range(self.__width						)]
						    for i in range(self.__height						)
						]
						return Matrix(lowerCamelCase_			,					self.__width			,					self.__height						)
					return None







				def 							__UpperCAmelCase					( self    :       Union[str, Any]						):

					"""simple docstring"""






					return self.__height







				def 							__UpperCAmelCase					( self    :       List[Any]						):

					"""simple docstring"""






					return self.__width







				def 							__UpperCAmelCase					( self    :       Optional[Any]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					if 0 <= x < self.__height and 0 <= y < self.__width:
						return self.__matrix[x][y]
					else:
						raise Exception('change_component: indices out of bounds'						)







				def 							__UpperCAmelCase					( self    :       Optional[Any]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       float						):

					"""simple docstring"""






					if 0 <= x < self.__height and 0 <= y < self.__width:
						_lowercase :    int							=							value
					else:
						raise Exception('change_component: indices out of bounds'						)







				def 							__UpperCAmelCase					( self    :       int			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					if self.__height != self.__width:
						raise Exception('Matrix is not square'						)
					_lowercase :    Union[str, Any]							=							self.__matrix[:x] + self.__matrix[x + 1 :]
					for i in range(len(lowerCamelCase_						)						):
						_lowercase :    int							=							minor[i][:y] + minor[i][y + 1 :]
					return Matrix(lowerCamelCase_			,					self.__width - 1			,					self.__height - 1						).determinant()







				def 							__UpperCAmelCase					( self    :       List[str]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					if self.__height != self.__width:
						raise Exception('Matrix is not square'						)
					if 0 <= x < self.__height and 0 <= y < self.__width:
						return (-1) ** (x + y) * self.minor(lowerCamelCase_			,					lowerCamelCase_						)
					else:
						raise Exception('Indices out of bounds'						)







				def 							__UpperCAmelCase					( self    :       Dict						):

					"""simple docstring"""






					if self.__height != self.__width:
						raise Exception('Matrix is not square'						)
					if self.__height < 1:
						raise Exception('Matrix has no element'						)
					elif self.__height == 1:
						return self.__matrix[0][0]
					elif self.__height == 2:
						return (
						    self.__matrix[0][0] * self.__matrix[1][1]
						    - self.__matrix[0][1] * self.__matrix[1][0]
						)
					else:
						_lowercase :    Union[str, Any]							=							[
						    self.__matrix[0][y] * self.cofactor(0			,					lowerCamelCase_						) for y in range(self.__width						)
						]
						return sum(lowerCamelCase_						)



def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	_lowercase :    list[list[float]]							=							[[0] * n for _ in range(__UpperCAmelCase			)]
	return Matrix(__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase			)







def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase			):






	"""simple docstring"""





	random.seed(__UpperCAmelCase			)
	_lowercase :    list[list[float]]							=							[
	    [random.randint(__UpperCAmelCase     ,__UpperCAmelCase			) for _ in range(__UpperCAmelCase			)] for _ in range(__UpperCAmelCase			)
	]
	return Matrix(__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase			)



