staged.

Chunk
1 parent 8a43d8ec
Showing 10 changed files with 310 additions and 48 deletions Show diff stats
.idea/Numerical.iml
chap1/1_3_infinite.py
chap1/1_3_infiniteseries.py
chap2/__init__.py
chap2/newton.py
chap3/__init__.py
chap3/cholesky.py
chap4/__init__.py
common.py
common.pyc
@@ -2,7 +2,7 @@
 <module type="PYTHON_MODULE" version="4">
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$" />
-    <orderEntry type="jdk" jdkName="Python 2.7.8 virtualenv at ~/.virtualenvs/env0" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="Python 2.7.6 virtualenv at ~/.virtualenvs/env0" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
 </module>
 \ No newline at end of file
@@ -0,0 +1,71 @@
+__author__ = 'chunk'
+
+import struct
+import numpy as np
+
+from  common import *
+
+def float2bits(f, fmt='bin'):
+    if fmt == 'hex':
+        return hex(struct.unpack('!l', struct.pack('!f', f))[0])
+    return bin(struct.unpack('!l', struct.pack('!f', f))[0])
+
+
+def double2bits(d, fmt='bin'):
+    if fmt == 'hex':
+        return hex(struct.unpack('!q', struct.pack('!d', d))[0])
+    return bin(struct.unpack('!q', struct.pack('!d', d))[0])
+
+
+def float2bin(num):
+    # http://stackoverflow.com/questions/16444726/binary-representation-of-float-in-python-bits-not-hex
+    bits = [bin(ord(c)).replace('0b', '').rjust(8, '0') for c in struct.pack('!f', num)]
+    print bits
+    return ''.join(bits)
+
+
+def double2bin(num):
+    bits = [bin(ord(c)).replace('0b', '').rjust(8, '0') for c in struct.pack('!d', num)]
+    print bits
+    return ''.join(bits)
+
+
+def infinite_float():
+    s = np.float32(0)
+    tmp = np.float32(-1)
+    i = 0
+    while s != tmp:
+        i += 1
+        tmp = s
+        s += np.float32(1.0 / i)
+
+    print i, s, tmp, float2bin(s)
+
+
+def infinite_double(n):
+    s = np.float64(0)
+    for i in range(1, n + 1):
+        s += np.float64(1.0 / i)
+    return s
+
+
+def testn0():
+    for i in range(100):
+        print i, np.log(i)
+        if np.log(i) >= 8:
+            print i
+
+
+if __name__ == '__main__':
+    # testn0()
+    # infinite_float()
+
+    # i = 1
+    # while infinite_double(i) < 16:
+    #     i += 1
+    # print i, infinite_double(i)
+    timer = Timer()
+    timer.mark()
+    infinite_double(10000000) # 1125899906842624
+    timer.report()
+    pass
@@ -1,47 +0,0 @@
-__author__ = 'chunk'
-
-import struct
-import numpy as np
-
-def float2bits(f, fmt='bin'):
-    if fmt == 'hex':
-        return hex(struct.unpack('!l', struct.pack('!f', f))[0])
-    return bin(struct.unpack('!l', struct.pack('!f', f))[0])
-
-
-def double2bits(d, fmt='bin'):
-    if fmt == 'hex':
-        return hex(struct.unpack('!q', struct.pack('!d', d))[0])
-    return bin(struct.unpack('!q', struct.pack('!d', d))[0])
-
-
-def float2bin(num):
-    # http://stackoverflow.com/questions/16444726/binary-representation-of-float-in-python-bits-not-hex
-    bits = [bin(ord(c)).replace('0b', '').rjust(8, '0') for c in struct.pack('!f', num)]
-    print bits
-    return ''.join(bits)
-
-
-def double2bin(num):
-    # http://stackoverflow.com/questions/16444726/binary-representation-of-float-in-python-bits-not-hex
-    bits = [bin(ord(c)).replace('0b', '').rjust(8, '0') for c in struct.pack('!d', num)]
-    print bits
-    return ''.join(bits)
-
-
-def infiniteseries():
-    s = np.float32(0)
-    tmp = np.float32(-1)
-    i = 0
-    while s != tmp:
-        i += 1
-        tmp = s
-        s += np.float32(1.0 / i)
-
-    print i, s, tmp
-
-
-if __name__ == '__main__':
-    print float2bin(1.0)
-    infiniteseries()
-    pass
@@ -0,0 +1 @@
+__author__ = 'chunk'
@@ -0,0 +1,67 @@
+__author__ = 'chunk'
+
+import numpy as np
+import math
+
+
+def deriv(fn):
+    dx = 0.00001
+    return lambda x: (fn(x + dx) - fn(x)) / dx
+
+
+def dampnm(fun, x0, lmbda, epsilon, gfun=None):
+    assert lmbda < 1 and lmbda > 0
+
+    if gfun == None:
+        gfun = deriv(fun)
+    x_new = x0
+    x_old = None
+    # while np.absolute(fun(x_new)) > epsilon:
+    while x_old == None or np.absolute(fun(x_new) - fun(x_old)) > epsilon:
+        x_old = x_new
+        s = fun(x_old) / gfun(x_old)
+        x_new = x_old - s
+        while np.absolute(fun(x_new)) >= np.absolute(fun(x_old)):
+            x_new = x_old - lmbda * s
+            lmbda /= 2.0
+        print lmbda, x_new
+    return x_new
+
+
+def test():
+    fn = lambda x: math.pow(x, 4) - x - 2
+    gfn = lambda x: 4 * math.pow(x, 3) - 1
+    print dampnm(fn, 1.5, 0.99, 0.00001, gfn)
+
+    fn = lambda x: math.pow(x, 3) - x - 1
+    gfn = lambda x: 3 * math.pow(x, 2) - 1
+    print dampnm(fn, 0.6, 0.99, 0.00001, gfn)
+
+    fn = lambda x: -math.pow(x, 3) + 5 * x
+    gfn = lambda x: -3 * math.pow(x, 2) + 5
+    print dampnm(fn, 1.2, 0.99, 0.00001, gfn)
+
+    # 0.99 1.375
+    # 0.99 1.35377701579
+    # 0.99 1.35321036029
+    # 0.99 1.3532099642
+    # 1.3532099642
+    # 0.01546875 1.13521875
+    # 0.01546875 1.36976137194
+    # 0.01546875 1.32649943078
+    # 0.01546875 1.32472090757
+    # 0.01546875 1.32471795725
+    # 0.01546875 1.32471795724
+    # 1.32471795724
+    # 0.2475 -1.90976470588
+    # 0.2475 -2.34458457506
+    # 0.2475 -2.24316474291
+    # 0.2475 -2.23610151441
+    # 0.2475 -2.23606797825
+    # 0.2475 -2.2360679775
+    # -2.2360679775
+
+if __name__ == '__main__':
+    test()
+
+    pass
@@ -0,0 +1 @@
+__author__ = 'chunk'
@@ -0,0 +1,92 @@
+__author__ = 'chunk'
+
+import numpy as np
+import math
+
+
+def calc_upper(U, b):
+    n = len(U)
+    assert len(b) == n
+    x = [0.0] * n
+    for i in reversed(range(n)):
+        if U[i][i] == 0:
+            raise Exception('u_ii == 0')
+        x[i] = b[i]
+        for j in reversed(range(i + 1, n)):
+            x[i] -= U[i][j] * x[j]
+        x[i] /= U[i][i]
+    return x
+
+
+def calc_lower(L, b):
+    n = len(L)
+    assert len(b) == n
+    x = [0.0] * n
+    for i in range(n):
+        if L[i][i] == 0:
+            raise Exception('l_ii == 0')
+        x[i] = b[i]
+        for j in range(i):
+            x[i] -= L[i][j] * x[j]
+        x[i] /= L[i][i]
+    return x
+
+
+def gen_hilbert(n):
+    return np.array([1.0 / (i + j + 1) for i in range(n) for j in range(n)]).reshape((n, -1))
+
+
+def gen_b(n, x=None):
+    if x == None:
+        x = [1] * n
+    return np.dot(gen_hilbert(n), x)
+
+
+def cholesky(A):
+    n = len(A)
+    for j in range(n):
+        for k in range(j):
+            A[j][j] -= (A[j][k] * A[j][k])
+        A[j][j] = math.sqrt(A[j][j])
+
+        for i in range(j + 1, n):
+            for k in range(j):
+                A[i][j] -= (A[i][k] * A[j][k])
+            A[i][j] /= A[j][j]
+
+    return np.array(A)
+
+
+def calculate(n):
+    H = gen_hilbert(n)
+    b = gen_b(n)
+    L = cholesky(H)
+    y = calc_lower(L, b)
+    x = calc_upper(L.T, y)
+    # validate:
+    # print np.dot(H, x) - b
+    return x, b - np.dot(H, x), [x[i] - 1.0 for i in range(n)]
+
+
+def test():
+    print gen_hilbert(3)
+    print gen_b(5)
+
+    U = [[1, -0.7, 0], [0, 1, -60], [0, 0, 155]]
+    b = [0.7, -61, 155]
+    print calc_upper(U, b)
+
+    L = [[1, 0, 0], [-60, 1, 0], [0, -0.7, 1]]
+    b = [1, -61, 0.7]
+    print calc_lower(L, b)
+
+    A = [[5, -1, -1], [-1, 3, -1], [-1, -1, 5]]
+    print cholesky(A)
+
+    x, r, delta = calculate(10)
+    print "%s\n%s\n%s\n" % (x, r, delta)
+
+
+if __name__ == '__main__':
+    test()
+    pass
@@ -0,0 +1 @@
+__author__ = 'chunk'
@@ -0,0 +1,76 @@
+"""
+Common utils.
+
+@author: chunk
+chunkplus@gmail.com
+2014 Dec
+"""
+__author__ = 'hadoop'
+
+import os, sys
+import time
+import StringIO
+import ConfigParser
+
+import numpy as np
+
+package_dir_imager = os.path.dirname(os.path.abspath(__file__))
+
+
+class Timer():
+    def __init__(self):
+        self.__newtime = time.time()
+        self.__oldtime = self.__newtime
+
+    def mark(self):
+        self.__oldtime = self.__newtime
+        self.__newtime = time.time()
+        return self.__newtime - self.__oldtime
+
+    def report(self):
+        print "%-24s%fs" % ("time elapsed:", self.mark())
+
+
+def ttimer():
+    newtime = time.time()
+    while True:
+        oldtime = newtime
+        newtime = time.time()
+        yield newtime - oldtime
+
+
+def ctimer():
+    newtime = time.clock()
+    while True:
+        oldtime = newtime
+        newtime = time.clock()
+        yield newtime - oldtime
+
+
+def bytes2bits(arry_bytes):
+    """
+    :param arry_bytes: 1-D np.unit8 array
+    :return: 1-D 0/1 array
+    """
+    hid_data_bits = [map(int, '{0:08b}'.format(byte)) for byte in arry_bytes]
+    return np.array(hid_data_bits).ravel()
+
+
+def bits2bytes(arry_bits):
+    """
+    :param arry_bits: 1-D 0/1 array
+    :return: 1-D np.unit8 array
+    """
+    str_bits = ''.join(map(str, arry_bits))
+    arry_bytes = [int(str_bits[i:i + 8], 2) for i in range(0, len(str_bits), 8)]
+    return np.array(arry_bytes, dtype=np.uint8).ravel()
+
+
+def test_grammer():
+    a = 'fsaf'
+    b = ['dasf', 'dff']
+    c = 'dgfsfdg'
+    # print a + b
+    print [a] + b  # ['fsaf', 'dasf', 'dff']
+    print [a] + [b]  # ['fsaf', ['dasf', 'dff']]
+    print [a] + [c]  # ['fsaf', 'dgfsfdg']
	@@ -2,7 +2,7 @@		@@ -2,7 +2,7 @@
2	<module type="PYTHON_MODULE" version="4">	2	<module type="PYTHON_MODULE" version="4">
3	<component name="NewModuleRootManager">	3	<component name="NewModuleRootManager">
4	<content url="file://$MODULE_DIR$" />	4	<content url="file://$MODULE_DIR$" />
5	- <orderEntry type="jdk" jdkName="Python 2.7.8 virtualenv at ~/.virtualenvs/env0" jdkType="Python SDK" />	5	+ <orderEntry type="jdk" jdkName="Python 2.7.6 virtualenv at ~/.virtualenvs/env0" jdkType="Python SDK" />
6	<orderEntry type="sourceFolder" forTests="false" />	6	<orderEntry type="sourceFolder" forTests="false" />
7	</component>	7	</component>
8	</module>	8	</module>
9	\ No newline at end of file	9	\ No newline at end of file
@@ -0,0 +1,71 @@		@@ -0,0 +1,71 @@
	1	+__author__ = 'chunk'
	2	+
	3	+import struct
	4	+import numpy as np
	5	+
	6	+from common import *
	7	+
	8	+def float2bits(f, fmt='bin'):
	9	+ if fmt == 'hex':
	10	+ return hex(struct.unpack('!l', struct.pack('!f', f))[0])
	11	+ return bin(struct.unpack('!l', struct.pack('!f', f))[0])
	12	+
	13	+
	14	+def double2bits(d, fmt='bin'):
	15	+ if fmt == 'hex':
	16	+ return hex(struct.unpack('!q', struct.pack('!d', d))[0])
	17	+ return bin(struct.unpack('!q', struct.pack('!d', d))[0])
	18	+
	19	+
	20	+def float2bin(num):
	21	+ # http://stackoverflow.com/questions/16444726/binary-representation-of-float-in-python-bits-not-hex
	22	+ bits = [bin(ord(c)).replace('0b', '').rjust(8, '0') for c in struct.pack('!f', num)]
	23	+ print bits
	24	+ return ''.join(bits)
	25	+
	26	+
	27	+def double2bin(num):
	28	+ bits = [bin(ord(c)).replace('0b', '').rjust(8, '0') for c in struct.pack('!d', num)]
	29	+ print bits
	30	+ return ''.join(bits)
	31	+
	32	+
	33	+def infinite_float():
	34	+ s = np.float32(0)
	35	+ tmp = np.float32(-1)
	36	+ i = 0
	37	+ while s != tmp:
	38	+ i += 1
	39	+ tmp = s
	40	+ s += np.float32(1.0 / i)
	41	+
	42	+ print i, s, tmp, float2bin(s)
	43	+
	44	+
	45	+def infinite_double(n):
	46	+ s = np.float64(0)
	47	+ for i in range(1, n + 1):
	48	+ s += np.float64(1.0 / i)
	49	+ return s
	50	+
	51	+
	52	+def testn0():
	53	+ for i in range(100):
	54	+ print i, np.log(i)
	55	+ if np.log(i) >= 8:
	56	+ print i
	57	+
	58	+
	59	+if __name__ == '__main__':
	60	+ # testn0()
	61	+ # infinite_float()
	62	+
	63	+ # i = 1
	64	+ # while infinite_double(i) < 16:
	65	+ # i += 1
	66	+ # print i, infinite_double(i)
	67	+ timer = Timer()
	68	+ timer.mark()
	69	+ infinite_double(10000000) # 1125899906842624
	70	+ timer.report()
	71	+ pass
	@@ -1,47 +0,0 @@	@@ -1,47 +0,0 @@
1	-__author__ = 'chunk'
2	-
3	-import struct
4	-import numpy as np
5	-
6	-def float2bits(f, fmt='bin'):
7	- if fmt == 'hex':
8	- return hex(struct.unpack('!l', struct.pack('!f', f))[0])
9	- return bin(struct.unpack('!l', struct.pack('!f', f))[0])
10	-
11	-
12	-def double2bits(d, fmt='bin'):
13	- if fmt == 'hex':
14	- return hex(struct.unpack('!q', struct.pack('!d', d))[0])
15	- return bin(struct.unpack('!q', struct.pack('!d', d))[0])
16	-
17	-
18	-def float2bin(num):
19	- # http://stackoverflow.com/questions/16444726/binary-representation-of-float-in-python-bits-not-hex
20	- bits = [bin(ord(c)).replace('0b', '').rjust(8, '0') for c in struct.pack('!f', num)]
21	- print bits
22	- return ''.join(bits)
23	-
24	-
25	-def double2bin(num):
26	- # http://stackoverflow.com/questions/16444726/binary-representation-of-float-in-python-bits-not-hex
27	- bits = [bin(ord(c)).replace('0b', '').rjust(8, '0') for c in struct.pack('!d', num)]
28	- print bits
29	- return ''.join(bits)
30	-
31	-
32	-def infiniteseries():
33	- s = np.float32(0)
34	- tmp = np.float32(-1)
35	- i = 0
36	- while s != tmp:
37	- i += 1
38	- tmp = s
39	- s += np.float32(1.0 / i)
40	-
41	- print i, s, tmp
42	-
43	-
44	-if __name__ == '__main__':
45	- print float2bin(1.0)
46	- infiniteseries()
47	- pass
@@ -0,0 +1,67 @@		@@ -0,0 +1,67 @@
	1	+__author__ = 'chunk'
	2	+
	3	+import numpy as np
	4	+import math
	5	+
	6	+
	7	+def deriv(fn):
	8	+ dx = 0.00001
	9	+ return lambda x: (fn(x + dx) - fn(x)) / dx
	10	+
	11	+
	12	+def dampnm(fun, x0, lmbda, epsilon, gfun=None):
	13	+ assert lmbda < 1 and lmbda > 0
	14	+
	15	+ if gfun == None:
	16	+ gfun = deriv(fun)
	17	+ x_new = x0
	18	+ x_old = None
	19	+ # while np.absolute(fun(x_new)) > epsilon:
	20	+ while x_old == None or np.absolute(fun(x_new) - fun(x_old)) > epsilon:
	21	+ x_old = x_new
	22	+ s = fun(x_old) / gfun(x_old)
	23	+ x_new = x_old - s
	24	+ while np.absolute(fun(x_new)) >= np.absolute(fun(x_old)):
	25	+ x_new = x_old - lmbda * s
	26	+ lmbda /= 2.0
	27	+ print lmbda, x_new
	28	+ return x_new
	29	+
	30	+
	31	+def test():
	32	+ fn = lambda x: math.pow(x, 4) - x - 2
	33	+ gfn = lambda x: 4 * math.pow(x, 3) - 1
	34	+ print dampnm(fn, 1.5, 0.99, 0.00001, gfn)
	35	+
	36	+ fn = lambda x: math.pow(x, 3) - x - 1
	37	+ gfn = lambda x: 3 * math.pow(x, 2) - 1
	38	+ print dampnm(fn, 0.6, 0.99, 0.00001, gfn)
	39	+
	40	+ fn = lambda x: -math.pow(x, 3) + 5 * x
	41	+ gfn = lambda x: -3 * math.pow(x, 2) + 5
	42	+ print dampnm(fn, 1.2, 0.99, 0.00001, gfn)
	43	+
	44	+ # 0.99 1.375
	45	+ # 0.99 1.35377701579
	46	+ # 0.99 1.35321036029
	47	+ # 0.99 1.3532099642
	48	+ # 1.3532099642
	49	+ # 0.01546875 1.13521875
	50	+ # 0.01546875 1.36976137194
	51	+ # 0.01546875 1.32649943078
	52	+ # 0.01546875 1.32472090757
	53	+ # 0.01546875 1.32471795725
	54	+ # 0.01546875 1.32471795724
	55	+ # 1.32471795724
	56	+ # 0.2475 -1.90976470588
	57	+ # 0.2475 -2.34458457506
	58	+ # 0.2475 -2.24316474291
	59	+ # 0.2475 -2.23610151441
	60	+ # 0.2475 -2.23606797825
	61	+ # 0.2475 -2.2360679775
	62	+ # -2.2360679775
	63	+
	64	+if __name__ == '__main__':
	65	+ test()
	66	+
	67	+ pass
@@ -0,0 +1,92 @@		@@ -0,0 +1,92 @@
	1	+__author__ = 'chunk'
	2	+
	3	+import numpy as np
	4	+import math
	5	+
	6	+
	7	+def calc_upper(U, b):
	8	+ n = len(U)
	9	+ assert len(b) == n
	10	+ x = [0.0] * n
	11	+ for i in reversed(range(n)):
	12	+ if U[i][i] == 0:
	13	+ raise Exception('u_ii == 0')
	14	+ x[i] = b[i]
	15	+ for j in reversed(range(i + 1, n)):
	16	+ x[i] -= U[i][j] * x[j]
	17	+ x[i] /= U[i][i]
	18	+ return x
	19	+
	20	+
	21	+def calc_lower(L, b):
	22	+ n = len(L)
	23	+ assert len(b) == n
	24	+ x = [0.0] * n
	25	+ for i in range(n):
	26	+ if L[i][i] == 0:
	27	+ raise Exception('l_ii == 0')
	28	+ x[i] = b[i]
	29	+ for j in range(i):
	30	+ x[i] -= L[i][j] * x[j]
	31	+ x[i] /= L[i][i]
	32	+ return x
	33	+
	34	+
	35	+def gen_hilbert(n):
	36	+ return np.array([1.0 / (i + j + 1) for i in range(n) for j in range(n)]).reshape((n, -1))
	37	+
	38	+
	39	+def gen_b(n, x=None):
	40	+ if x == None:
	41	+ x = [1] * n
	42	+ return np.dot(gen_hilbert(n), x)
	43	+
	44	+
	45	+def cholesky(A):
	46	+ n = len(A)
	47	+ for j in range(n):
	48	+ for k in range(j):
	49	+ A[j][j] -= (A[j][k] * A[j][k])
	50	+ A[j][j] = math.sqrt(A[j][j])
	51	+
	52	+ for i in range(j + 1, n):
	53	+ for k in range(j):
	54	+ A[i][j] -= (A[i][k] * A[j][k])
	55	+ A[i][j] /= A[j][j]
	56	+
	57	+ return np.array(A)
	58	+
	59	+
	60	+def calculate(n):
	61	+ H = gen_hilbert(n)
	62	+ b = gen_b(n)
	63	+ L = cholesky(H)
	64	+ y = calc_lower(L, b)
	65	+ x = calc_upper(L.T, y)
	66	+ # validate:
	67	+ # print np.dot(H, x) - b
	68	+ return x, b - np.dot(H, x), [x[i] - 1.0 for i in range(n)]
	69	+
	70	+
	71	+def test():
	72	+ print gen_hilbert(3)
	73	+ print gen_b(5)
	74	+
	75	+ U = [[1, -0.7, 0], [0, 1, -60], [0, 0, 155]]
	76	+ b = [0.7, -61, 155]
	77	+ print calc_upper(U, b)
	78	+
	79	+ L = [[1, 0, 0], [-60, 1, 0], [0, -0.7, 1]]
	80	+ b = [1, -61, 0.7]
	81	+ print calc_lower(L, b)
	82	+
	83	+ A = [[5, -1, -1], [-1, 3, -1], [-1, -1, 5]]
	84	+ print cholesky(A)
	85	+
	86	+ x, r, delta = calculate(10)
	87	+ print "%s\n%s\n%s\n" % (x, r, delta)
	88	+
	89	+
	90	+if __name__ == '__main__':
	91	+ test()
	92	+ pass
@@ -0,0 +1,76 @@		@@ -0,0 +1,76 @@
	1	+"""
	2	+Common utils.
	3	+
	4	+@author: chunk
	5	+chunkplus@gmail.com
	6	+2014 Dec
	7	+"""
	8	+__author__ = 'hadoop'
	9	+
	10	+import os, sys
	11	+import time
	12	+import StringIO
	13	+import ConfigParser
	14	+
	15	+import numpy as np
	16	+
	17	+package_dir_imager = os.path.dirname(os.path.abspath(__file__))
	18	+
	19	+
	20	+class Timer():
	21	+ def __init__(self):
	22	+ self.__newtime = time.time()
	23	+ self.__oldtime = self.__newtime
	24	+
	25	+ def mark(self):
	26	+ self.__oldtime = self.__newtime
	27	+ self.__newtime = time.time()
	28	+ return self.__newtime - self.__oldtime
	29	+
	30	+ def report(self):
	31	+ print "%-24s%fs" % ("time elapsed:", self.mark())
	32	+
	33	+
	34	+def ttimer():
	35	+ newtime = time.time()
	36	+ while True:
	37	+ oldtime = newtime
	38	+ newtime = time.time()
	39	+ yield newtime - oldtime
	40	+
	41	+
	42	+def ctimer():
	43	+ newtime = time.clock()
	44	+ while True:
	45	+ oldtime = newtime
	46	+ newtime = time.clock()
	47	+ yield newtime - oldtime
	48	+
	49	+
	50	+def bytes2bits(arry_bytes):
	51	+ """
	52	+ :param arry_bytes: 1-D np.unit8 array
	53	+ :return: 1-D 0/1 array
	54	+ """
	55	+ hid_data_bits = [map(int, '{0:08b}'.format(byte)) for byte in arry_bytes]
	56	+ return np.array(hid_data_bits).ravel()
	57	+
	58	+
	59	+def bits2bytes(arry_bits):
	60	+ """
	61	+ :param arry_bits: 1-D 0/1 array
	62	+ :return: 1-D np.unit8 array
	63	+ """
	64	+ str_bits = ''.join(map(str, arry_bits))
	65	+ arry_bytes = [int(str_bits[i:i + 8], 2) for i in range(0, len(str_bits), 8)]
	66	+ return np.array(arry_bytes, dtype=np.uint8).ravel()
	67	+
	68	+
	69	+def test_grammer():
	70	+ a = 'fsaf'
	71	+ b = ['dasf', 'dff']
	72	+ c = 'dgfsfdg'
	73	+ # print a + b
	74	+ print [a] + b # ['fsaf', 'dasf', 'dff']
	75	+ print [a] + [b] # ['fsaf', ['dasf', 'dff']]
	76	+ print [a] + [c] # ['fsaf', 'dgfsfdg']