1. Python / Говнокод #23059

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    #!/usr/bin/python
    #encoding: utf-8
    
    import sys
    import time
    import socket
    import asyncore
    import exceptions
    
    from socket import AF_INET, SOCK_STREAM
    from asyncore import dispatcher
    from threading import Thread, RLock
    
    class PiCalcThread(Thread):
        def __init__(self, buffer, lock):
            Thread.__init__(self)
            self.buffer = buffer
            self.lock = lock
            
        def run(self):
            """ See http://web.comlab.ox.ac.uk/oucl/work/jeremy.gibbons/publications/spigot.pdf """
            q,r,t,k,n,l = 1,0,1,1,3,3
            
            while True:
                if 4*q+r-t < n*t:
                    self.lock.acquire()
                    self.buffer.newDigits(str(n))
                    self.lock.release()
                    
                    q,r,t,k,n,l = (10*q,10*(r-n*t),t,k,(10*(3*q+r))/t-10*n,l)
                else:
                    q,r,t,k,n,l = (q*k,(2*q+r)*l,t*l,k+1,(q*(7*k+2)+r*l)/(t*l),l+2)
                
                time.sleep(0.001)
    
    class PiGenerator(list):
        def __init__(self):
            list.__init__(self)
            self.calculator = None
            self.lock = RLock()
            self.digits = ''
        
        def subscribe(self, obj):  
            self.lock.acquire()
            try:     
                self.append(obj)
                self._notify(obj=obj)
            finally:
                self.lock.release()            
                
            if not self.calculator:
                self.calculator = PiCalcThread(self, self.lock)
                self.calculator.start()
            else:
                if len(self) > 0:
                    self._resumeCalculator()
                    
        def unsubscribe(self, obj):
            self.lock.acquire()
            self.remove(obj)   
            self.lock.release()
                 
            if len(self) <= 0:
                self._pauseCalulator()
                
        def _pauseCalulator(self):
            self.lock.acquire()
        
        def _resumeCalculator(self):
            try: self.lock.release()
            except exceptions.AssertionError: pass
                
        def _notify(self, digits = None, obj = None):
            objs = [obj] if obj else self
            digits = digits or self.digits
            
            for obj in objs:
                obj.update(digits)
            
        def newDigits(self, digits):
            self.digits += digits
            self._notify(digits)

    Запостил: Lis, 23 Мая 2017

    Комментарии (5) RSS

    Добавить комментарий