rapydscript-ng 0.7.24 → 0.8.1

package/src/lib/math.pyj

@@ -19,40 +19,53 @@ pi = Math.PI
 e = Math.E
 inf = Infinity
 
+
 ########################################
 # Number-theoretic and representation functions
 ########################################
 def ceil(x):
     return Math.ceil(x)
+
+
 def copysign(x, y):
     x = Math.abs(x)
     if y < 0:
         return -x
     else:
         return x
+
+
 def fabs(x):
     return Math.abs(x)
+
+
 def factorial(x):
     if Math.abs(int(x)) is not x:
-        raise ValueError("factorial() only accepts integral values")
+        raise ValueError('factorial() only accepts integral values')
     factorial.cache = []
-    r = def(n):
+    r = def (n):
         if n is 0 or n is 1:
             return 1
         if not factorial.cache[n]:
-            factorial.cache[n] = r(n-1) * n
+            factorial.cache[n] = r(n - 1) * n
         return factorial.cache[n]
     return r(x)
+
+
 def floor(x):
     return Math.floor(x)
+
+
 def fmod(x, y):
     # javascript's % operator isn't consistent with C fmod implementation, this function is
     while y <= x:
         x -= y
     return x
+
+
 def fsum(iterable):
     # like Python's fsum, this method is much more resilient to rounding errors than regular sum
-    partials = []   # sorted, non-overlapping partial sums
+    partials = []  # sorted, non-overlapping partial sums
     for x in iterable:
         i = 0
         for y in partials:
@@ -64,34 +77,49 @@ def fsum(iterable):
                 partials[i] = lo
                 i += 1
             x = hi
-        #partials[i:] = [x]
-        partials.splice(i, partials.length-i, x)
+        # partials[i:] = [x]
+        partials.splice(i, partials.length - i, x)
     return sum(partials)
+
+
 def isinf(x):
     return not isFinite(x)
+
+
 def isnan(x):
     return isNaN(x)
+
+
 def modf(x):
     m = fmod(x, 1)
-    return m, x-m
+    return m, x - m
+
+
 def trunc(x):
     return x | 0
 
+
 ########################################
 # Power and logarithmic functions
 ########################################
 def exp(x):
     return Math.exp(x)
+
+
 def expm1(x):
     # NOTE: Math.expm1() is currently only implemented in Firefox, this provides alternative implementation
     # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/expm1
-    #return Math.expm1(x)
+    # return Math.expm1(x)
     if Math.abs(x) < 1e-5:
-        return x + 0.5*x*x
+        return x + 0.5 * x * x
     else:
         return Math.exp(x) - 1
+
+
 def log(x, base=e):
-    return Math.log(x)/Math.log(base)
+    return Math.log(x) / Math.log(base)
+
+
 def log1p(x):
     # NOTE: Math.log1p() is currently only implemented in Firefox, this provides alternative implementation
     # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log1p
@@ -109,37 +137,62 @@ def log1p(x):
         else:
             ret += Math.pow(x, i) / i
     return ret
+
+
 def log10(x):
     # NOTE: Math.log10() is currently only implemented in Firefox, this provides alternative implementation
     # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log10
     # I didn't find a more accurate algorithm so I'm using the basic implementation
-    return Math.log(x)/Math.LN10
+    return Math.log(x) / Math.LN10
+
+
 def pow(x, y):
     if x < 0 and int(y) is not y:
         raise ValueError('math domain error')
     if isnan(y) and x is 1:
         return 1
     return Math.pow(x, y)
+
+
 def sqrt(x):
     return Math.sqrt(x)
 
+
 ########################################
 # Trigonometric functions
 ########################################
-def acos(x):        return Math.acos(x)
-def asin(x):        return Math.asin(x)
-def atan(x):        return Math.atan(x)
-def atan2(y, x):    return Math.atan2(y, x)
-def cos(x):         return Math.cos(x)
-def sin(x):         return Math.sin(x)
-def hypot(x, y):    return Math.sqrt(x*x + y*y)
-def tan(x):         return Math.tan(x)
+def acos(x): return Math.acos(x)
+
+
+def asin(x): return Math.asin(x)
+
+
+def atan(x): return Math.atan(x)
+
+
+def atan2(y, x): return Math.atan2(y, x)
+
+
+def cos(x): return Math.cos(x)
+
+
+def sin(x): return Math.sin(x)
+
+
+def hypot(x, y): return Math.sqrt(x * x + y * y)
+
+
+def tan(x): return Math.tan(x)
+
 
 ########################################
 # Angular conversion
 ########################################
-def degrees(x):     return x*180/pi
-def radians(x):     return x*pi/180
+def degrees(x): return x * 180 / pi
+
+
+def radians(x): return x * pi / 180
+
 
 ########################################
 # Hyperbolic functions
@@ -147,47 +200,55 @@ def radians(x):     return x*pi/180
 def acosh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
     # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acosh
-    return Math.log(x + Math.sqrt(x*x - 1))
+    return Math.log(x + Math.sqrt(x * x - 1))
+
+
 def asinh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
     # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asinh
-    return Math.log(x + Math.sqrt(x*x + 1))
+    return Math.log(x + Math.sqrt(x * x + 1))
+
+
 def atanh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
     # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atanh
     return 0.5 * Math.log((1 + x) / (1 - x))
+
+
 def cosh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
     # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cosh
     return (Math.exp(x) + Math.exp(-x)) / 2
+
+
 def sinh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
     # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sinh
     return (Math.exp(x) - Math.exp(-x)) / 2
+
+
 def tanh(x):
     # NOTE: will be replaced with official, when it becomes mainstream
     # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tanh
     return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x))
 
-
-
-#import stdlib
-#print(math.ceil(4.2))
-#print(math.floor(4.2))
-#print(math.fabs(-6))
-#print(math.copysign(-5, 7))
-#print(math.factorial(4))
-#print(math.fmod(-1e100, 1e100))
-#
-#d = [0.9999999, 1, 2, 3]
-#print(sum(d), math.fsum(d))
-#print(math.isinf(5), math.isinf(Infinity))
-#print(math.modf(5.5))
-#print(math.trunc(2.6), math.trunc(-2.6))
-#print(math.exp(1e-5), math.expm1(1e-5))
-#print(math.log(10), math.log(10, 1000))
-#print(math.log1p(1e-15), math.log1p(1))
-#print(math.log10(1000), math.log(1000, 10))
-#print(math.pow(1, 0), math.pow(1, NaN), math.pow(0, 0), math.pow(NaN, 0), math.pow(4,3), math.pow(100, -2))
-#print(math.hypot(3,4))
-#print(math.acosh(2), math.asinh(1), math.atanh(0.5), math.cosh(1), math.cosh(-1), math.sinh(1), math.tanh(1))
+    # import stdlib
+    # print(math.ceil(4.2))
+    # print(math.floor(4.2))
+    # print(math.fabs(-6))
+    # print(math.copysign(-5, 7))
+    # print(math.factorial(4))
+    # print(math.fmod(-1e100, 1e100))
+    #
+    # d = [0.9999999, 1, 2, 3]
+    # print(sum(d), math.fsum(d))
+    # print(math.isinf(5), math.isinf(Infinity))
+    # print(math.modf(5.5))
+    # print(math.trunc(2.6), math.trunc(-2.6))
+    # print(math.exp(1e-5), math.expm1(1e-5))
+    # print(math.log(10), math.log(10, 1000))
+    # print(math.log1p(1e-15), math.log1p(1))
+    # print(math.log10(1000), math.log(1000, 10))
+    # print(math.pow(1, 0), math.pow(1, NaN), math.pow(0, 0), math.pow(NaN, 0), math.pow(4,3), math.pow(100, -2))
+    # print(math.hypot(3,4))
+    # print(math.acosh(2), math.asinh(1), math.atanh(0.5), math.cosh(1), math.cosh(-1), math.sinh(1), math.tanh(1))

package/src/lib/operator.pyj

@@ -1,11 +1,11 @@
-add = __add__ = def(x, y): return x + y
-sub = __sub__ = def(x, y): return x - y
-mul = __mul__ = def(x, y): return x * y
-div = __div__ = def(x, y): return x / y
+add = __add__ = def (x, y): return x + y
+sub = __sub__ = def (x, y): return x - y
+mul = __mul__ = def (x, y): return x * y
+div = __div__ = def (x, y): return x / y
 
-lt = __lt__ = def(x, y): return x < y
-le = __le__ = def(x, y): return x <= y
-eq = __eq__ = def(x, y): return x is y
-ne = __ne__ = def(x, y): return x is not y
-ge = __ge__ = def(x, y): return x >= y
-gt = __gt__ = def(x, y): return x > y
+lt = __lt__ = def (x, y): return x < y
+le = __le__ = def (x, y): return x <= y
+eq = __eq__ = def (x, y): return x is y
+ne = __ne__ = def (x, y): return x is not y
+ge = __ge__ = def (x, y): return x >= y
+gt = __gt__ = def (x, y): return x > y

package/src/lib/pythonize.pyj

@@ -2,6 +2,7 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 # globals: ρσ_str
 
+
 def strings():
     string_funcs = set((
         'capitalize strip lstrip rstrip islower isupper isspace lower upper swapcase'
@@ -11,7 +12,7 @@ def strings():
     if not arguments.length:
         exclude = {'split', 'replace'}
     elif arguments[0]:
-        exclude = Array.prototype.slice.call(arguments)
+        exclude = Array.from (arguments)
     else:
         exclude = None
     if exclude:

package/src/lib/random.pyj

@@ -21,7 +21,7 @@
     'key_j': 0
 }
 
-ρσ_get_random_byte = def():
+ρσ_get_random_byte = def ():
     ρσ_seed_state.key_i = (ρσ_seed_state.key_i + 1) % 256
     ρσ_seed_state.key_j = (ρσ_seed_state.key_j + ρσ_seed_state.key[ρσ_seed_state.key_i]) % 256
     ρσ_seed_state.key[ρσ_seed_state.key_i], ρσ_seed_state.key[ρσ_seed_state.key_j] = \
@@ -29,6 +29,7 @@
     return ρσ_seed_state.key[(ρσ_seed_state.key[ρσ_seed_state.key_i] + \
             ρσ_seed_state.key[ρσ_seed_state.key_j]) % 256]
 
+
 def seed(x=Date().getTime()):
     ρσ_seed_state.key_i = ρσ_seed_state.key_j = 0
     if jstype(x) is 'number':
@@ -43,6 +44,7 @@ def seed(x=Date().getTime()):
         ρσ_seed_state.key[i], ρσ_seed_state.key[j] = ρσ_seed_state.key[j], ρσ_seed_state.key[i]
 seed()
 
+
 def random():
     n = 0
     m = 1
@@ -51,6 +53,7 @@ def random():
         m *= 256
     return v'n / 0x10000000000000000'
 
+
 def randrange():
     if arguments.length is 1:
         return randbelow(int(arguments[0]))
@@ -64,26 +67,29 @@ def randrange():
     if step is 1:
         if width > 0:
             return start + randbelow(width)
-        raise ValueError("empty range for randrange()")
+        raise ValueError('empty range for randrange()')
     if step > 0:
         n = (width + step - 1) // step
     elif step < 0:
         n = (width + step + 1) // step
     else:
-        raise ValueError("zero step for randrange()")
+        raise ValueError('zero step for randrange()')
     if n <= 0:
         raise ValueError(f"empty range in randrange({start}, {stop}, {step})")
     return start + step * randbelow(n)
 
 
 def randint(a, b):
-    return int(random()*(b-a+1) + a)
+    return int(random() * (b - a + 1) + a)
+
 
 def uniform(a, b):
-    return random()*(b-a) + a
+    return random() * (b - a) + a
+
 
 def randbelow(n):
-    return Math.floor(random()*n)
+    return Math.floor(random() * n)
+
 
 def choice(seq):
     if seq.length > 0:
@@ -91,28 +97,29 @@ def choice(seq):
     else:
         raise IndexError()
 
+
 # uses Fisher-Yates algorithm to shuffle an array
 def shuffle(x, random_f=random):
     for i in range(x.length):
-        j = Math.floor(random_f() * (i+1))
+        j = Math.floor(random_f() * (i + 1))
         x[i], x[j] = x[j], x[i]
     return x
 
+
 # similar to shuffle, but only shuffles a subset and creates a copy
 def sample(population, k):
     x = population.slice()
-    for i in range(population.length-1, population.length-k-1, -1):
-        j = Math.floor(random() * (i+1))
+    for i in range(population.length - 1, population.length - k - 1, -1):
+        j = Math.floor(random() * (i + 1))
         x[i], x[j] = x[j], x[i]
-    return x.slice(population.length-k)
-
-
-#import stdlib
-#a = range(50)
-#random.seed(5)
-#print(random.choice(a))
-#print(random.shuffle(a))
-#print(random.randrange(10))
-#print(random.randint(1,5))
-#print(random.uniform(1,5))
-#print(random.sample(range(20),5))
+    return x.slice(population.length - k)
+
+    # import stdlib
+    # a = range(50)
+    # random.seed(5)
+    # print(random.choice(a))
+    # print(random.shuffle(a))
+    # print(random.randrange(10))
+    # print(random.randint(1,5))
+    # print(random.uniform(1,5))
+    # print(random.sample(range(20),5))