



'''simple docstring'''





from __future__ import annotations

from collections.abc import Callable
from typing import Generic, TypeVar

lowercase_			=  TypeVar("T")
lowercase_			=  TypeVar("U")






class __A      (  Generic[T, U]						):



 '''simple docstring'''







 def __init__(self			,       A			,       A	)   ->					Any:


      """simple docstring"""



      _a     =  key
      _a     =  val
      _a     =  0
      _a     =  None
      _a     =  None



 def __repr__(self	)   ->					str:


      """simple docstring"""



      return "Node: key: {}, val: {}, freq: {}, has next: {}, has prev: {}".format(
          self.key			,       self.val			,       self.freq			,       self.next is not None			,       self.prev is not None	)






class __A      (  Generic[T, U]						):



 '''simple docstring'''







 def __init__(self	)   ->					None:


      """simple docstring"""



      _a     =  DoubleLinkedListNode(A			,       A	)
      _a     =  DoubleLinkedListNode(A			,       A	)
      _a  ,   _a     =  self.rear, self.head



 def __repr__(self	)   ->					str:


      """simple docstring"""



      _a     =  ['''DoubleLinkedList''']
      _a     =  self.head
      while node.next is not None:
           rep.append(str(A	)	)
           _a     =  node.next
      rep.append(str(self.rear	)	)
      return ",\n    ".join(A	)



 def  a__  (self			,       A	)   ->					None:


      """simple docstring"""



      _a     =  self.rear.prev

      # All nodes other than self.head are guaranteed to have non-None previous
      assert previous is not None

      _a     =  node
      _a     =  previous
      _a     =  node
      _a     =  self.rear
      node.freq += 1
      self._position_node(A	)



 def  a__  (self			,       A	)   ->					None:


      """simple docstring"""



      while node.prev is not None and node.prev.freq > node.freq:
           # swap node with previous node
           _a     =  node.prev

           _a     =  previous_node.prev
           _a     =  node.prev
           _a     =  previous_node
           _a     =  node



 def  a__  (self			,       A	)   ->					DoubleLinkedListNode[T, U] | None:


      """simple docstring"""



      if node.prev is None or node.next is None:
           return None

      _a     =  node.next
      _a     =  node.prev
      _a     =  None
      _a     =  None
      return node






class __A      (  Generic[T, U]						):



 '''simple docstring'''







 __lowerCamelCase   :	dict[Callable[[T], U], LFUCache[T, U]]										=	{}



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


      """simple docstring"""



      _a     =  DoubleLinkedList()
      _a     =  capacity
      _a     =  0
      _a     =  0
      _a     =  0
      _a     =  {}



 def __repr__(self	)   ->					str:


      """simple docstring"""



      return (
          f'''CacheInfo(hits={self.hits}, misses={self.miss}, '''
          f'''capacity={self.capacity}, current_size={self.num_keys})'''
      )



 def __contains__(self			,       A	)   ->					bool:


      """simple docstring"""



      return key in self.cache



 def  a__  (self			,       A	)   ->					U | None:


      """simple docstring"""



      if key in self.cache:
           self.hits += 1
           _a     =  self.cache[key]
           _a     =  self.list.remove(self.cache[key]	)
           assert node == value_node

           # node is guaranteed not None because it is in self.cache
           assert node is not None
           self.list.add(A	)
           return node.val
      self.miss += 1
      return None



 def  a__  (self			,       A			,       A	)   ->					None:


      """simple docstring"""



      if key not in self.cache:
           if self.num_keys >= self.capacity:
                # delete first node when over capacity
                _a     =  self.list.head.next

                # guaranteed to have a non-None first node when num_keys > 0
                # explain to type checker via assertions
                assert first_node is not None
                assert first_node.key is not None
                assert self.list.remove(A	) is not None
                # first_node guaranteed to be in list

                del self.cache[first_node.key]
                self.num_keys -= 1
           _a     =  DoubleLinkedListNode(A			,       A	)
           self.list.add(self.cache[key]	)
           self.num_keys += 1

      else:
           _a     =  self.list.remove(self.cache[key]	)
           assert node is not None  # node guaranteed to be in list
           _a     =  value
           self.list.add(A	)



 @classmethod
 def  a__  (cls			,       A = 128	)   ->					Callable[[Callable[[T], U]], Callable[..., U]]:


      """simple docstring"""



      def cache_decorator_inner(A	) -> Callable[..., U]:
           def cache_decorator_wrapper(*A	) -> U:
                if func not in cls.decorator_function_to_instance_map:
                     _a     =  LFUCache(A	)

                _a     =  cls.decorator_function_to_instance_map[func].get(args[0]	)
                if result is None:
                     _a     =  func(*A	)
                     cls.decorator_function_to_instance_map[func].put(args[0]			,       A	)
                return result

           def cache_info() -> LFUCache[T, U]:
                return cls.decorator_function_to_instance_map[func]

           setattr(A			,       '''cache_info'''			,       A	)  # noqa: B010

           return cache_decorator_wrapper

      return cache_decorator_inner


if __name__ == "__main__":
  import doctest

  doctest.testmod()








'''simple docstring'''





import warnings
from collections.abc import Callable
from typing import Any

import numpy
from matplotlib import pyplot

lowercase_			=  0.25 + 0.0J
lowercase_			=  -0.4 + 0.6J
lowercase_			=  -0.1 + 0.651J
lowercase_			=  -2.0
lowercase_			=  56
lowercase_			=  2.0
lowercase_			=  666




def lowerCAmelCase  (__A  ,     __A):



     """simple docstring"""



     return numpy.exp(__A) + c_parameter




def lowerCAmelCase  (__A  ,     __A):



     """simple docstring"""



     return z_values * z_values + c_parameter




def lowerCAmelCase  (__A  ,     __A):



     """simple docstring"""



     _a     =  numpy.linspace(-window_size  ,     __A  ,     __A)
     _a     =  x.reshape((nb_pixels, 1))
     _a     =  numpy.linspace(-window_size  ,     __A  ,     __A)
     _a     =  y.reshape((1, nb_pixels))
     return x + 1.0J * y




def lowerCAmelCase  (__A  ,     __A  ,     __A  ,     __A  ,     __A = None  ,     ):



     """simple docstring"""



     _a     =  z_a.astype('''complex64''')
     for _ in range(__A):
          _a     =  eval_function(__A  ,     __A)
          if infinity is not None:
               numpy.nan_to_num(__A  ,     copy=__A  ,     nan=__A)
               _a     =  infinity
     return z_n




def lowerCAmelCase  (__A  ,     __A  ,     __A  ,     __A  ,     ):



     """simple docstring"""



     _a     =  (abs(__A)).transpose()
     _a     =  abs_z_final[::-1, :]
     pyplot.matshow(abs_z_final < escape_radius)
     pyplot.title(F'''Julia set of ${function_label}$, $c={function_params}$''')
     pyplot.show()




def lowerCAmelCase  ():



     """simple docstring"""



     warnings.filterwarnings(
         '''ignore'''  ,     category=__A  ,     message='''overflow encountered in multiply''')
     warnings.filterwarnings(
         '''ignore'''  ,     category=__A  ,     message='''invalid value encountered in multiply'''  ,     )
     warnings.filterwarnings(
         '''ignore'''  ,     category=__A  ,     message='''overflow encountered in absolute''')
     warnings.filterwarnings(
         '''ignore'''  ,     category=__A  ,     message='''overflow encountered in exp''')


if __name__ == "__main__":
  lowercase_			=  prepare_grid(window_size, nb_pixels)

  ignore_overflow_warnings()  # See file header for explanations

  lowercase_			=  24
  lowercase_			=  2 * abs(c_cauliflower) + 1
  lowercase_			=  iterate_function(
      eval_quadratic_polynomial,
      c_cauliflower,
      nb_iterations,
      z_a,
      infinity=1.1 * escape_radius,
  )
  show_results("z^2+c", c_cauliflower, escape_radius, z_final)

  lowercase_			=  64
  lowercase_			=  2 * abs(c_polynomial_a) + 1
  lowercase_			=  iterate_function(
      eval_quadratic_polynomial,
      c_polynomial_a,
      nb_iterations,
      z_a,
      infinity=1.1 * escape_radius,
  )
  show_results("z^2+c", c_polynomial_a, escape_radius, z_final)

  lowercase_			=  161
  lowercase_			=  2 * abs(c_polynomial_a) + 1
  lowercase_			=  iterate_function(
      eval_quadratic_polynomial,
      c_polynomial_a,
      nb_iterations,
      z_a,
      infinity=1.1 * escape_radius,
  )
  show_results("z^2+c", c_polynomial_a, escape_radius, z_final)

  lowercase_			=  12
  lowercase_			=  1_0000.0
  lowercase_			=  iterate_function(
      eval_exponential,
      c_exponential,
      nb_iterations,
      z_a + 2,
      infinity=1.0e10,
  )
  show_results("e^z+c", c_exponential, escape_radius, z_final)



