

'''simple docstring'''
import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)







class 							A__    (       unittest.TestCase  ):





  def 						A  (		self      :	str )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Vector([1, 2, 3] )
       self.assertEqual(x.component(0 )							,					1 )
       self.assertEqual(x.component(2 )							,					3 )
       _SCREAMING_SNAKE_CASE							    =Vector()





  def 						A  (		self      :	Dict )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Vector([0, 0, 0, 0, 0, 1] )
       self.assertEqual(str(_a )							,					'(0,0,0,0,0,1)' )





  def 						A  (		self      :	Optional[Any] )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Vector([1, 2, 3, 4] )
       self.assertEqual(len(_a )							,					4 )





  def 						A  (		self      :	Union[str, Any] )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Vector([1, 2] )
       _SCREAMING_SNAKE_CASE							    =Vector([1, 2, 3, 4, 5] )
       _SCREAMING_SNAKE_CASE							    =Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0] )
       _SCREAMING_SNAKE_CASE							    =Vector([1, -1, 1, -1, 2, -3, 4, -5] )
       self.assertAlmostEqual(x.euclidean_length()							,					2.2_36							,					3 )
       self.assertAlmostEqual(y.euclidean_length()							,					7.4_16							,					3 )
       self.assertEqual(z.euclidean_length()							,					0 )
       self.assertAlmostEqual(w.euclidean_length()							,					7.6_16							,					3 )





  def 						A  (		self      :	str )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Vector([1, 2, 3] )
       _SCREAMING_SNAKE_CASE							    =Vector([1, 1, 1] )
       self.assertEqual((x + y).component(0 )							,					2 )
       self.assertEqual((x + y).component(1 )							,					3 )
       self.assertEqual((x + y).component(2 )							,					4 )





  def 						A  (		self      :	Optional[int] )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Vector([1, 2, 3] )
       _SCREAMING_SNAKE_CASE							    =Vector([1, 1, 1] )
       self.assertEqual((x - y).component(0 )							,					0 )
       self.assertEqual((x - y).component(1 )							,					1 )
       self.assertEqual((x - y).component(2 )							,					2 )





  def 						A  (		self      :	Tuple )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Vector([1, 2, 3] )
       _SCREAMING_SNAKE_CASE							    =Vector([2, -1, 4] )  # for test of dot product
       _SCREAMING_SNAKE_CASE							    =Vector([1, -2, -1] )
       self.assertEqual(str(x * 3.0 )							,					'(3.0,6.0,9.0)' )
       self.assertEqual((a * b)							,					0 )





  def 						A  (		self      :	List[str] )	->    None:





       '''simple docstring'''






       self.assertEqual(str(zero_vector(10 ) ).count('0' )							,					10 )





  def 						A  (		self      :	Optional[int] )	->    None:





       '''simple docstring'''






       self.assertEqual(str(unit_basis_vector(3							,					1 ) )							,					'(0,1,0)' )





  def 						A  (		self      :	Optional[Any] )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Vector([1, 2, 3] )
       _SCREAMING_SNAKE_CASE							    =Vector([1, 0, 1] )
       self.assertEqual(str(axpy(2							,					_a							,					_a ) )							,					'(3,4,7)' )





  def 						A  (		self      :	List[Any] )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Vector([1, 0, 0, 0, 0, 0] )
       _SCREAMING_SNAKE_CASE							    =x.copy()
       self.assertEqual(str(_a )							,					str(_a ) )





  def 						A  (		self      :	Optional[Any] )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Vector([1, 0, 0] )
       x.change_component(0							,					0 )
       x.change_component(1							,					1 )
       self.assertEqual(str(_a )							,					'(0,1,0)' )





  def 						A  (		self      :	int )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							,					3							,					3 )
       self.assertEqual('|1,2,3|\n|2,4,5|\n|6,7,8|\n'							,					str(_a ) )





  def 						A  (		self      :	str )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							,					3							,					3 )
       _SCREAMING_SNAKE_CASE							    =[[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
       for x in range(a.height() ):
            for y in range(a.width() ):
                 self.assertEqual(minors[x][y]							,					a.minor(_a							,					_a ) )





  def 						A  (		self      :	Optional[Any] )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							,					3							,					3 )
       _SCREAMING_SNAKE_CASE							    =[[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
       for x in range(a.height() ):
            for y in range(a.width() ):
                 self.assertEqual(cofactors[x][y]							,					a.cofactor(_a							,					_a ) )





  def 						A  (		self      :	List[str] )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							,					3							,					3 )
       self.assertEqual(-5							,					a.determinant() )





  def 						A  (		self      :	int )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]							,					3							,					3 )
       _SCREAMING_SNAKE_CASE							    =Vector([1, 2, 3] )
       self.assertEqual('(14,32,50)'							,					str(a * x ) )
       self.assertEqual('|2,4,6|\n|8,10,12|\n|14,16,18|\n'							,					str(a * 2 ) )





  def 						A  (		self      :	List[Any] )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							,					3							,					3 )
       a.change_component(0							,					2							,					5 )
       self.assertEqual('|1,2,5|\n|2,4,5|\n|6,7,8|\n'							,					str(_a ) )





  def 						A  (		self      :	Union[str, Any] )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							,					3							,					3 )
       self.assertEqual(7							,					a.component(2							,					1 )							,					0.01 )





  def 						A  (		self      :	Tuple )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							,					3							,					3 )
       _SCREAMING_SNAKE_CASE							    =Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]							,					3							,					3 )
       self.assertEqual('|2,4,10|\n|4,8,10|\n|12,14,18|\n'							,					str(a + b ) )





  def 						A  (		self      :	Any )	->    None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							,					3							,					3 )
       _SCREAMING_SNAKE_CASE							    =Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]							,					3							,					3 )
       self.assertEqual('|0,0,-4|\n|0,0,0|\n|0,0,-2|\n'							,					str(a - b ) )





  def 						A  (		self      :	int )	->    None:





       '''simple docstring'''






       self.assertEqual(
           '|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n'							,					str(square_zero_matrix(5 ) )							,					)


if __name__ == "__main__":
     unittest.main()



'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase :      Any					 =     {
    "configuration_funnel": ["FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP", "FunnelConfig"],
    "convert_funnel_original_tf_checkpoint_to_pytorch": [],
    "tokenization_funnel": ["FunnelTokenizer"],
}

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCamelCase :      Optional[Any]					 =     ["FunnelTokenizerFast"]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCamelCase :      List[str]					 =     [
         "FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST",
         "FunnelBaseModel",
         "FunnelForMaskedLM",
         "FunnelForMultipleChoice",
         "FunnelForPreTraining",
         "FunnelForQuestionAnswering",
         "FunnelForSequenceClassification",
         "FunnelForTokenClassification",
         "FunnelModel",
         "FunnelPreTrainedModel",
         "load_tf_weights_in_funnel",
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCamelCase :      Union[str, Any]					 =     [
         "TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST",
         "TFFunnelBaseModel",
         "TFFunnelForMaskedLM",
         "TFFunnelForMultipleChoice",
         "TFFunnelForPreTraining",
         "TFFunnelForQuestionAnswering",
         "TFFunnelForSequenceClassification",
         "TFFunnelForTokenClassification",
         "TFFunnelModel",
         "TFFunnelPreTrainedModel",
     ]


if TYPE_CHECKING:
     from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig
     from .tokenization_funnel import FunnelTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_funnel_fast import FunnelTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_funnel import (
              FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
              FunnelBaseModel,
              FunnelForMaskedLM,
              FunnelForMultipleChoice,
              FunnelForPreTraining,
              FunnelForQuestionAnswering,
              FunnelForSequenceClassification,
              FunnelForTokenClassification,
              FunnelModel,
              FunnelPreTrainedModel,
              load_tf_weights_in_funnel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_funnel import (
              TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFFunnelBaseModel,
              TFFunnelForMaskedLM,
              TFFunnelForMultipleChoice,
              TFFunnelForPreTraining,
              TFFunnelForQuestionAnswering,
              TFFunnelForSequenceClassification,
              TFFunnelForTokenClassification,
              TFFunnelModel,
              TFFunnelPreTrainedModel,
          )

else:
     import sys

     lowerCamelCase :      Optional[Any]					 =     _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
