rapydscript-ns 0.8.2 → 0.8.4

package/src/lib/math.pyj

@@ -1,193 +1,193 @@
-###########################################################
-# RapydScript Standard Library
-# Author: Alexander Tsepkov
-# Copyright 2013 Pyjeon Software LLC
-# License: Apache License    2.0
-# This library is covered under Apache license, so that
-# you can distribute it with your RapydScript applications.
-###########################################################
-
-
-# basic implementation of Python's 'math' library
-
-# NOTE: this is only meant to aid those porting lots of Python code into RapydScript,
-# if you're writing a new RapydScript application, in most cases you probably want to
-# use JavaScript's Math module directly instead
-
-
-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")
-    factorial.cache = []
-    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
-        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
-    for x in iterable:
-        i = 0
-        for y in partials:
-            if Math.abs(x) < Math.abs(y):
-                x, y = y, x
-            hi = x + y
-            lo = y - (hi - x)
-            if lo:
-                partials[i] = lo
-                i += 1
-            x = hi
-        #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
-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)
-    if Math.abs(x) < 1e-5:
-        return x + 0.5*x*x
-    else:
-        return Math.exp(x) - 1
-def log(x, base=e):
-    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
-    # this version has been taken from http://phpjs.org/functions/log1p/
-    # admittedly it's not as accurate as MDN version, as you can see from math.log1p(1) result
-    ret = 0
-    n = 50
-    if x <= -1:
-        return Number.NEGATIVE_INFINITY
-    if x < 0 or x > 1:
-        return Math.log(1 + x)
-    for i in range(1, n):
-        if i % 2 is 0:
-            ret -= Math.pow(x, i) / i
-        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
-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)
-
-########################################
-# Angular conversion
-########################################
-def degrees(x):     return x*180/pi
-def radians(x):     return x*pi/180
-
-########################################
-# Hyperbolic functions
-########################################
-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))
-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))
-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))
+###########################################################
+# RapydScript Standard Library
+# Author: Alexander Tsepkov
+# Copyright 2013 Pyjeon Software LLC
+# License: Apache License    2.0
+# This library is covered under Apache license, so that
+# you can distribute it with your RapydScript applications.
+###########################################################
+
+
+# basic implementation of Python's 'math' library
+
+# NOTE: this is only meant to aid those porting lots of Python code into RapydScript,
+# if you're writing a new RapydScript application, in most cases you probably want to
+# use JavaScript's Math module directly instead
+
+
+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")
+    factorial.cache = []
+    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
+        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
+    for x in iterable:
+        i = 0
+        for y in partials:
+            if Math.abs(x) < Math.abs(y):
+                x, y = y, x
+            hi = x + y
+            lo = y - (hi - x)
+            if lo:
+                partials[i] = lo
+                i += 1
+            x = hi
+        #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
+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)
+    if Math.abs(x) < 1e-5:
+        return x + 0.5*x*x
+    else:
+        return Math.exp(x) - 1
+def log(x, base=e):
+    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
+    # this version has been taken from http://phpjs.org/functions/log1p/
+    # admittedly it's not as accurate as MDN version, as you can see from math.log1p(1) result
+    ret = 0
+    n = 50
+    if x <= -1:
+        return Number.NEGATIVE_INFINITY
+    if x < 0 or x > 1:
+        return Math.log(1 + x)
+    for i in range(1, n):
+        if i % 2 is 0:
+            ret -= Math.pow(x, i) / i
+        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
+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)
+
+########################################
+# Angular conversion
+########################################
+def degrees(x):     return x*180/pi
+def radians(x):     return x*pi/180
+
+########################################
+# Hyperbolic functions
+########################################
+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))
+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))
+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))

package/src/lib/numpy.pyj

@@ -1055,7 +1055,7 @@ def sort(a, axis=-1):
     a = asarray(a)
     if a.ndim is 1 or axis is None:
         data = a._data.slice()
-        data.sort(def(x, y): return x - y;)
+        data.jssort(def(x, y): return x - y;)
         return ndarray(a.shape.slice(), a.dtype, data, True)
     # 2D sort along last axis (axis=1 or axis=-1)
     if axis < 0:
@@ -1066,7 +1066,7 @@ def sort(a, axis=-1):
     if axis is 1:
         for i in range(rows):
             row = a._data.slice(i * cols, (i + 1) * cols)
-            row.sort(def(x, y): return x - y;)
+            row.jssort(def(x, y): return x - y;)
             for v in row:
                 new_data.push(v)
     elif axis is 0:
@@ -1074,7 +1074,7 @@ def sort(a, axis=-1):
             col = []
             for i in range(rows):
                 col.push(a._data[i * cols + j])
-            col.sort(def(x, y): return x - y;)
+            col.jssort(def(x, y): return x - y;)
             for i in range(rows):
                 new_data[i * cols + j] = col[i]
         if new_data.length is 0:
@@ -1089,14 +1089,14 @@ def argsort(a, axis=-1):
         for i in range(a.size):
             indices.push(i)
         data = a._data.slice()
-        indices.sort(def(i, j): return data[i] - data[j];)
+        indices.jssort(def(i, j): return data[i] - data[j];)
         return ndarray([a.size], 'int32', indices, True)
     # Flatten and sort
     data = a._data.slice()
     indices = []
     for i in range(data.length):
         indices.push(i)
-    indices.sort(def(i, j): return data[i] - data[j];)
+    indices.jssort(def(i, j): return data[i] - data[j];)
     return ndarray([indices.length], 'int32', indices, True)
 
 def searchsorted(a, v, side='left'):
@@ -1157,7 +1157,7 @@ def where(condition, x=None, y=None):
 def median(a, axis=None):
     a = asarray(a)
     data = a._data.slice()
-    data.sort(def(x, y): return x - y;)
+    data.jssort(def(x, y): return x - y;)
     n = data.length
     if n % 2 is 1:
         return data[Math.floor(n / 2)]
@@ -1166,7 +1166,7 @@ def median(a, axis=None):
 def percentile(a, q, axis=None):
     a = asarray(a)
     data = a._data.slice()
-    data.sort(def(x, y): return x - y;)
+    data.jssort(def(x, y): return x - y;)
     n = data.length
     idx = q / 100.0 * (n - 1)
     lo = Math.floor(idx)
@@ -1497,7 +1497,7 @@ def union1d(ar1, ar2):
         if not seen[key]:
             seen[key] = True
             unique.push(v)
-    unique.sort(def(a, b): return a - b;)
+    unique.jssort(def(a, b): return a - b;)
     return ndarray([unique.length], 'float64', unique, True)
 
 def intersect1d(ar1, ar2):
@@ -1513,7 +1513,7 @@ def intersect1d(ar1, ar2):
         if s[key] and not seen[key]:
             seen[key] = True
             result.push(v)
-    result.sort(def(a, b): return a - b;)
+    result.jssort(def(a, b): return a - b;)
     return ndarray([result.length], 'float64', result, True)
 
 def setdiff1d(ar1, ar2):
@@ -1529,7 +1529,7 @@ def setdiff1d(ar1, ar2):
         if not s[key] and not seen[key]:
             seen[key] = True
             result.push(v)
-    result.sort(def(a, b): return a - b;)
+    result.jssort(def(a, b): return a - b;)
     return ndarray([result.length], 'float64', result, True)
 
 def in1d(ar1, ar2):

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
-
-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
+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

package/src/lib/pythonize.pyj

@@ -1,20 +1,20 @@
-# vim:fileencoding=utf-8
-# 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 title'
-        ' center count endswith startswith find rfind index rindex format join ljust rjust'
-        ' partition rpartition replace split rsplit splitlines zfill').split(' '))
-
-    if not arguments.length:
-        exclude = {'split', 'replace'}
-    elif arguments[0]:
-        exclude = Array.prototype.slice.call(arguments)
-    else:
-        exclude = None
-    if exclude:
-        string_funcs = string_funcs.difference(set(exclude))
-    for name in string_funcs:
-        String.prototype[name] = ρσ_str.prototype[name]
+# vim:fileencoding=utf-8
+# 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 title'
+        ' center count endswith startswith find rfind index rindex format join ljust rjust'
+        ' partition rpartition replace split rsplit splitlines zfill expandtabs').split(' '))
+
+    if not arguments.length:
+        exclude = {'split', 'replace'}
+    elif arguments[0]:
+        exclude = Array.prototype.slice.call(arguments)
+    else:
+        exclude = None
+    if exclude:
+        string_funcs = string_funcs.difference(set(exclude))
+    for name in string_funcs:
+        String.prototype[name] = ρσ_str.prototype[name]