Example #1
0
 def test_basic(self):
     assert_(np.isscalar(3))
     assert_(not np.isscalar([3]))
     assert_(not np.isscalar((3, )))
     assert_(np.isscalar(3j))
     assert_(np.isscalar(long(10)))
     assert_(np.isscalar(4.0))
    def check_function(self, t):
        assert_(t(123) == 123, repr(t(123)))
        assert_(t(123.6) == 123)
        assert_(t(long(123)) == 123)
        assert_(t('123') == 123)
        assert_(t(-123) == -123)
        assert_(t([123]) == 123)
        assert_(t((123,)) == 123)
        assert_(t(array(123)) == 123)
        assert_(t(array([123])) == 123)
        assert_(t(array([[123]])) == 123)
        assert_(t(array([123], 'b')) == 123)
        assert_(t(array([123], 'h')) == 123)
        assert_(t(array([123], 'i')) == 123)
        assert_(t(array([123], 'l')) == 123)
        assert_(t(array([123], 'B')) == 123)
        assert_(t(array([123], 'f')) == 123)
        assert_(t(array([123], 'd')) == 123)

        # assert_raises(ValueError, t, array([123],'S3'))
        assert_raises(ValueError, t, 'abc')

        assert_raises(IndexError, t, [])
        assert_raises(IndexError, t, ())

        assert_raises(Exception, t, t)
        assert_raises(Exception, t, {})

        if t.__doc__.split()[0] in ['t8', 's8']:
            assert_raises(OverflowError, t, 100000000000000000000000)
            assert_raises(OverflowError, t, 10000000011111111111111.23)
    def check_function(self, t):
        assert_(t(123) == 123, repr(t(123)))
        assert_(t(123.6) == 123)
        assert_(t(long(123)) == 123)
        assert_(t("123") == 123)
        assert_(t(-123) == -123)
        assert_(t([123]) == 123)
        assert_(t((123, )) == 123)
        assert_(t(array(123)) == 123)
        assert_(t(array([123])) == 123)
        assert_(t(array([[123]])) == 123)
        assert_(t(array([123], "b")) == 123)
        assert_(t(array([123], "h")) == 123)
        assert_(t(array([123], "i")) == 123)
        assert_(t(array([123], "l")) == 123)
        assert_(t(array([123], "B")) == 123)
        assert_(t(array([123], "f")) == 123)
        assert_(t(array([123], "d")) == 123)

        # assert_raises(ValueError, t, array([123],'S3'))
        assert_raises(ValueError, t, "abc")

        assert_raises(IndexError, t, [])
        assert_raises(IndexError, t, ())

        assert_raises(Exception, t, t)
        assert_raises(Exception, t, {})

        if t.__doc__.split()[0] in ["t8", "s8"]:
            assert_raises(OverflowError, t, 100000000000000000000000)
            assert_raises(OverflowError, t, 10000000011111111111111.23)
Example #4
0
    def check_function(self, t):
        assert_( t(123)==123, repr(t(123)))
        assert_( t(123.6)==123)
        assert_( t(long(123))==123)
        assert_( t('123')==123)
        assert_( t(-123)==-123)
        assert_( t([123])==123)
        assert_( t((123,))==123)
        assert_( t(array(123))==123)
        assert_( t(array([123]))==123)
        assert_( t(array([[123]]))==123)
        assert_( t(array([123], 'b'))==123)
        assert_( t(array([123], 'h'))==123)
        assert_( t(array([123], 'i'))==123)
        assert_( t(array([123], 'l'))==123)
        assert_( t(array([123], 'B'))==123)
        assert_( t(array([123], 'f'))==123)
        assert_( t(array([123], 'd'))==123)

        #assert_raises(ValueError, t, array([123],'S3'))
        assert_raises(ValueError, t, 'abc')

        assert_raises(IndexError, t, [])
        assert_raises(IndexError, t, ())

        assert_raises(Exception, t, t)
        assert_raises(Exception, t, {})

        if t.__doc__.split()[0] in ['t8', 's8']:
            assert_raises(OverflowError, t, 100000000000000000000000)
            assert_raises(OverflowError, t, 10000000011111111111111.23)
 def test_r1array(self):
     """Test to make sure equivalent Travis O's r1array function"""
     assert_(atleast_1d(3).shape == (1, ))
     assert_(atleast_1d(3j).shape == (1, ))
     assert_(atleast_1d(long(3)).shape == (1, ))
     assert_(atleast_1d(3.0).shape == (1, ))
     assert_(atleast_1d([[2, 3], [4, 5]]).shape == (2, 2))
Example #6
0
 def test_basic(self):
     assert_(np.isscalar(3))
     assert_(not np.isscalar([3]))
     assert_(not np.isscalar((3,)))
     assert_(np.isscalar(3j))
     assert_(np.isscalar(long(10)))
     assert_(np.isscalar(4.0))
Example #7
0
 def test_r1array(self):
     """ Test to make sure equivalent Travis O's r1array function
     """
     assert_(atleast_1d(3).shape == (1,))
     assert_(atleast_1d(3j).shape == (1,))
     assert_(atleast_1d(long(3)).shape == (1,))
     assert_(atleast_1d(3.0).shape == (1,))
     assert_(atleast_1d([[2, 3], [4, 5]]).shape == (2, 2))
def test_shares_memory_api():
    x = np.zeros([4, 5, 6], dtype=np.int8)

    assert_equal(np.shares_memory(x, x), True)
    assert_equal(np.shares_memory(x, x.copy()), False)

    a = x[:,::2,::3]
    b = x[:,::3,::2]
    assert_equal(np.shares_memory(a, b), True)
    assert_equal(np.shares_memory(a, b, max_work=None), True)
    assert_raises(np.TooHardError, np.shares_memory, a, b, max_work=1)
    assert_raises(np.TooHardError, np.shares_memory, a, b, max_work=long(1))
Example #9
0
def test_shares_memory_api():
    x = np.zeros([4, 5, 6], dtype=np.int8)

    assert_equal(np.shares_memory(x, x), True)
    assert_equal(np.shares_memory(x, x.copy()), False)

    a = x[:,::2,::3]
    b = x[:,::3,::2]
    assert_equal(np.shares_memory(a, b), True)
    assert_equal(np.shares_memory(a, b, max_work=None), True)
    assert_raises(np.TooHardError, np.shares_memory, a, b, max_work=1)
    assert_raises(np.TooHardError, np.shares_memory, a, b, max_work=long(1))
Example #10
0
    def check_function(self, t):
        tname = t.__doc__.split()[0]
        if tname in ['t0', 't8', 's0', 's8']:
            err = 1e-5
        else:
            err = 0.0
        assert_(abs(t(234j) - 234.0j) <= err)
        assert_(abs(t(234.6) - 234.6) <= err)
        assert_(abs(t(long(234)) - 234.0) <= err)
        assert_(abs(t(234.6 + 3j) - (234.6 + 3j)) <= err)
        #assert_( abs(t('234')-234.)<=err)
        #assert_( abs(t('234.6')-234.6)<=err)
        assert_(abs(t(-234) + 234.) <= err)
        assert_(abs(t([234]) - 234.) <= err)
        assert_(abs(t((234,)) - 234.) <= err)
        assert_(abs(t(array(234)) - 234.) <= err)
        assert_(abs(t(array(23 + 4j, 'F')) - (23 + 4j)) <= err)
        assert_(abs(t(array([234])) - 234.) <= err)
        assert_(abs(t(array([[234]])) - 234.) <= err)
        assert_(abs(t(array([234], 'b')) + 22.) <= err)
        assert_(abs(t(array([234], 'h')) - 234.) <= err)
        assert_(abs(t(array([234], 'i')) - 234.) <= err)
        assert_(abs(t(array([234], 'l')) - 234.) <= err)
        assert_(abs(t(array([234], 'q')) - 234.) <= err)
        assert_(abs(t(array([234], 'f')) - 234.) <= err)
        assert_(abs(t(array([234], 'd')) - 234.) <= err)
        assert_(abs(t(array([234 + 3j], 'F')) - (234 + 3j)) <= err)
        assert_(abs(t(array([234], 'D')) - 234.) <= err)

        #assert_raises(TypeError, t, array([234], 'a1'))
        assert_raises(TypeError, t, 'abc')

        assert_raises(IndexError, t, [])
        assert_raises(IndexError, t, ())

        assert_raises(TypeError, t, t)
        assert_raises(TypeError, t, {})

        try:
            r = t(10 ** 400)
            assert_(repr(r) in ['(inf+0j)', '(Infinity+0j)'], repr(r))
        except OverflowError:
            pass
Example #11
0
    def check_function(self, t):
        tname = t.__doc__.split()[0]
        if tname in ["t0", "t8", "s0", "s8"]:
            err = 1e-5
        else:
            err = 0.0
        assert_(abs(t(234j) - 234.0j) <= err)
        assert_(abs(t(234.6) - 234.6) <= err)
        assert_(abs(t(long(234)) - 234.0) <= err)
        assert_(abs(t(234.6 + 3j) - (234.6 + 3j)) <= err)
        # assert_( abs(t('234')-234.)<=err)
        # assert_( abs(t('234.6')-234.6)<=err)
        assert_(abs(t(-234) + 234.0) <= err)
        assert_(abs(t([234]) - 234.0) <= err)
        assert_(abs(t((234,)) - 234.0) <= err)
        assert_(abs(t(array(234)) - 234.0) <= err)
        assert_(abs(t(array(23 + 4j, "F")) - (23 + 4j)) <= err)
        assert_(abs(t(array([234])) - 234.0) <= err)
        assert_(abs(t(array([[234]])) - 234.0) <= err)
        assert_(abs(t(array([234], "b")) + 22.0) <= err)
        assert_(abs(t(array([234], "h")) - 234.0) <= err)
        assert_(abs(t(array([234], "i")) - 234.0) <= err)
        assert_(abs(t(array([234], "l")) - 234.0) <= err)
        assert_(abs(t(array([234], "q")) - 234.0) <= err)
        assert_(abs(t(array([234], "f")) - 234.0) <= err)
        assert_(abs(t(array([234], "d")) - 234.0) <= err)
        assert_(abs(t(array([234 + 3j], "F")) - (234 + 3j)) <= err)
        assert_(abs(t(array([234], "D")) - 234.0) <= err)

        # assert_raises(TypeError, t, array([234], 'a1'))
        assert_raises(TypeError, t, "abc")

        assert_raises(IndexError, t, [])
        assert_raises(IndexError, t, ())

        assert_raises(TypeError, t, t)
        assert_raises(TypeError, t, {})

        try:
            r = t(10 ** 400)
            assert_(repr(r) in ["(inf+0j)", "(Infinity+0j)"], repr(r))
        except OverflowError:
            pass
Example #12
0
    def check_function(self, t):
        tname = t.__doc__.split()[0]
        if tname in ['t0', 't8', 's0', 's8']:
            err = 1e-5
        else:
            err = 0.0
        assert_( abs(t(234j)-234.0j)<=err)
        assert_( abs(t(234.6)-234.6)<=err)
        assert_( abs(t(long(234))-234.0)<=err)
        assert_( abs(t(234.6+3j)-(234.6+3j))<=err)
        #assert_( abs(t('234')-234.)<=err)
        #assert_( abs(t('234.6')-234.6)<=err)
        assert_( abs(t(-234)+234.)<=err)
        assert_( abs(t([234])-234.)<=err)
        assert_( abs(t((234,))-234.)<=err)
        assert_( abs(t(array(234))-234.)<=err)
        assert_( abs(t(array(23+4j, 'F'))-(23+4j))<=err)
        assert_( abs(t(array([234]))-234.)<=err)
        assert_( abs(t(array([[234]]))-234.)<=err)
        assert_( abs(t(array([234], 'b'))+22.)<=err)
        assert_( abs(t(array([234], 'h'))-234.)<=err)
        assert_( abs(t(array([234], 'i'))-234.)<=err)
        assert_( abs(t(array([234], 'l'))-234.)<=err)
        assert_( abs(t(array([234], 'q'))-234.)<=err)
        assert_( abs(t(array([234], 'f'))-234.)<=err)
        assert_( abs(t(array([234], 'd'))-234.)<=err)
        assert_( abs(t(array([234+3j], 'F'))-(234+3j))<=err)
        assert_( abs(t(array([234], 'D'))-234.)<=err)

        #assert_raises(TypeError, t, array([234], 'a1'))
        assert_raises(TypeError, t, 'abc')

        assert_raises(IndexError, t, [])
        assert_raises(IndexError, t, ())

        assert_raises(TypeError, t, t)
        assert_raises(TypeError, t, {})

        try:
            r = t(10**400)
            assert_( repr(r) in ['(inf+0j)', '(Infinity+0j)'], repr(r))
        except OverflowError:
            pass
Example #13
0
    def check_function(self, t):
        tname = t.__doc__.split()[0]
        if tname in ["t0", "t8", "s0", "s8"]:
            err = 1e-5
        else:
            err = 0.0
        assert_(abs(t(234j) - 234.0j) <= err)
        assert_(abs(t(234.6) - 234.6) <= err)
        assert_(abs(t(long(234)) - 234.0) <= err)
        assert_(abs(t(234.6 + 3j) - (234.6 + 3j)) <= err)
        # assert_( abs(t('234')-234.)<=err)
        # assert_( abs(t('234.6')-234.6)<=err)
        assert_(abs(t(-234) + 234.0) <= err)
        assert_(abs(t([234]) - 234.0) <= err)
        assert_(abs(t((234,)) - 234.0) <= err)
        assert_(abs(t(array(234)) - 234.0) <= err)
        assert_(abs(t(array(23 + 4j, "F")) - (23 + 4j)) <= err)
        assert_(abs(t(array([234])) - 234.0) <= err)
        assert_(abs(t(array([[234]])) - 234.0) <= err)
        assert_(abs(t(array([234], "b")) + 22.0) <= err)
        assert_(abs(t(array([234], "h")) - 234.0) <= err)
        assert_(abs(t(array([234], "i")) - 234.0) <= err)
        assert_(abs(t(array([234], "l")) - 234.0) <= err)
        assert_(abs(t(array([234], "q")) - 234.0) <= err)
        assert_(abs(t(array([234], "f")) - 234.0) <= err)
        assert_(abs(t(array([234], "d")) - 234.0) <= err)
        assert_(abs(t(array([234 + 3j], "F")) - (234 + 3j)) <= err)
        assert_(abs(t(array([234], "D")) - 234.0) <= err)

        # assert_raises(TypeError, t, array([234], 'a1'))
        assert_raises(TypeError, t, "abc")

        assert_raises(IndexError, t, [])
        assert_raises(IndexError, t, ())

        assert_raises(TypeError, t, t)
        assert_raises(TypeError, t, {})

        try:
            r = t(10 ** 400)
            assert_(repr(r) in ["(inf+0j)", "(Infinity+0j)"], repr(r))
        except OverflowError:
            pass
    def check_function(self, t):
        if t.__doc__.split()[0] in ["t0", "t4", "s0", "s4"]:
            err = 1e-5
        else:
            err = 0.0
        assert_(abs(t(234) - 234.0) <= err)
        assert_(abs(t(234.6) - 234.6) <= err)
        assert_(abs(t(long(234)) - 234.0) <= err)
        assert_(abs(t("234") - 234) <= err)
        assert_(abs(t("234.6") - 234.6) <= err)
        assert_(abs(t(-234) + 234) <= err)
        assert_(abs(t([234]) - 234) <= err)
        assert_(abs(t((234, )) - 234.0) <= err)
        assert_(abs(t(array(234)) - 234.0) <= err)
        assert_(abs(t(array([234])) - 234.0) <= err)
        assert_(abs(t(array([[234]])) - 234.0) <= err)
        assert_(abs(t(array([234], "b")) + 22) <= err)
        assert_(abs(t(array([234], "h")) - 234.0) <= err)
        assert_(abs(t(array([234], "i")) - 234.0) <= err)
        assert_(abs(t(array([234], "l")) - 234.0) <= err)
        assert_(abs(t(array([234], "B")) - 234.0) <= err)
        assert_(abs(t(array([234], "f")) - 234.0) <= err)
        assert_(abs(t(array([234], "d")) - 234.0) <= err)
        if t.__doc__.split()[0] in ["t0", "t4", "s0", "s4"]:
            assert_(t(1e200) == t(1e300))  # inf

        # assert_raises(ValueError, t, array([234], 'S1'))
        assert_raises(ValueError, t, "abc")

        assert_raises(IndexError, t, [])
        assert_raises(IndexError, t, ())

        assert_raises(Exception, t, t)
        assert_raises(Exception, t, {})

        try:
            r = t(10**400)
            assert_(repr(r) in ["inf", "Infinity"], repr(r))
        except OverflowError:
            pass
    def check_function(self, t):
        if t.__doc__.split()[0] in ['t0', 't4', 's0', 's4']:
            err = 1e-5
        else:
            err = 0.0
        assert_(abs(t(234) - 234.0) <= err)
        assert_(abs(t(234.6) - 234.6) <= err)
        assert_(abs(t(long(234)) - 234.0) <= err)
        assert_(abs(t('234') - 234) <= err)
        assert_(abs(t('234.6') - 234.6) <= err)
        assert_(abs(t(-234) + 234) <= err)
        assert_(abs(t([234]) - 234) <= err)
        assert_(abs(t((234,)) - 234.) <= err)
        assert_(abs(t(array(234)) - 234.) <= err)
        assert_(abs(t(array([234])) - 234.) <= err)
        assert_(abs(t(array([[234]])) - 234.) <= err)
        assert_(abs(t(array([234], 'b')) + 22) <= err)
        assert_(abs(t(array([234], 'h')) - 234.) <= err)
        assert_(abs(t(array([234], 'i')) - 234.) <= err)
        assert_(abs(t(array([234], 'l')) - 234.) <= err)
        assert_(abs(t(array([234], 'B')) - 234.) <= err)
        assert_(abs(t(array([234], 'f')) - 234.) <= err)
        assert_(abs(t(array([234], 'd')) - 234.) <= err)
        if t.__doc__.split()[0] in ['t0', 't4', 's0', 's4']:
            assert_(t(1e200) == t(1e300))  # inf

        #assert_raises(ValueError, t, array([234], 'S1'))
        assert_raises(ValueError, t, 'abc')

        assert_raises(IndexError, t, [])
        assert_raises(IndexError, t, ())

        assert_raises(Exception, t, t)
        assert_raises(Exception, t, {})

        try:
            r = t(10 ** 400)
            assert_(repr(r) in ['inf', 'Infinity'], repr(r))
        except OverflowError:
            pass
Example #16
0
 def check_function(self, t):
     assert_(t(True) == 1, repr(t(True)))
     assert_(t(False) == 0, repr(t(False)))
     assert_(t(0) == 0)
     assert_(t(None) == 0)
     assert_(t(0.0) == 0)
     assert_(t(0j) == 0)
     assert_(t(1j) == 1)
     assert_(t(234) == 1)
     assert_(t(234.6) == 1)
     assert_(t(long(234)) == 1)
     assert_(t(234.6 + 3j) == 1)
     assert_(t("234") == 1)
     assert_(t("aaa") == 1)
     assert_(t("") == 0)
     assert_(t([]) == 0)
     assert_(t(()) == 0)
     assert_(t({}) == 0)
     assert_(t(t) == 1)
     assert_(t(-234) == 1)
     assert_(t(10**100) == 1)
     assert_(t([234]) == 1)
     assert_(t((234, )) == 1)
     assert_(t(array(234)) == 1)
     assert_(t(array([234])) == 1)
     assert_(t(array([[234]])) == 1)
     assert_(t(array([234], "b")) == 1)
     assert_(t(array([234], "h")) == 1)
     assert_(t(array([234], "i")) == 1)
     assert_(t(array([234], "l")) == 1)
     assert_(t(array([234], "f")) == 1)
     assert_(t(array([234], "d")) == 1)
     assert_(t(array([234 + 3j], "F")) == 1)
     assert_(t(array([234], "D")) == 1)
     assert_(t(array(0)) == 0)
     assert_(t(array([0])) == 0)
     assert_(t(array([[0]])) == 0)
     assert_(t(array([0j])) == 0)
     assert_(t(array([1])) == 1)
     assert_raises(ValueError, t, array([0, 0]))
Example #17
0
    def check_function(self, t):
        if t.__doc__.split()[0] in ['t0', 't4', 's0', 's4']:
            err = 1e-5
        else:
            err = 0.0
        assert_(abs(t(234) - 234.0) <= err)
        assert_(abs(t(234.6) - 234.6) <= err)
        assert_(abs(t(long(234)) - 234.0) <= err)
        assert_(abs(t('234') - 234) <= err)
        assert_(abs(t('234.6') - 234.6) <= err)
        assert_(abs(t(-234) + 234) <= err)
        assert_(abs(t([234]) - 234) <= err)
        assert_(abs(t((234, )) - 234.) <= err)
        assert_(abs(t(array(234)) - 234.) <= err)
        assert_(abs(t(array([234])) - 234.) <= err)
        assert_(abs(t(array([[234]])) - 234.) <= err)
        assert_(abs(t(array([234], 'b')) + 22) <= err)
        assert_(abs(t(array([234], 'h')) - 234.) <= err)
        assert_(abs(t(array([234], 'i')) - 234.) <= err)
        assert_(abs(t(array([234], 'l')) - 234.) <= err)
        assert_(abs(t(array([234], 'B')) - 234.) <= err)
        assert_(abs(t(array([234], 'f')) - 234.) <= err)
        assert_(abs(t(array([234], 'd')) - 234.) <= err)
        if t.__doc__.split()[0] in ['t0', 't4', 's0', 's4']:
            assert_(t(1e200) == t(1e300))  # inf

        #assert_raises(ValueError, t, array([234], 'S1'))
        assert_raises(ValueError, t, 'abc')

        assert_raises(IndexError, t, [])
        assert_raises(IndexError, t, ())

        assert_raises(Exception, t, t)
        assert_raises(Exception, t, {})

        try:
            r = t(10**400)
            assert_(repr(r) in ['inf', 'Infinity'], repr(r))
        except OverflowError:
            pass
Example #18
0
 def check_function(self, t):
     assert_( t(True)==1, repr(t(True)))
     assert_( t(False)==0, repr(t(False)))
     assert_( t(0)==0)
     assert_( t(None)==0)
     assert_( t(0.0)==0)
     assert_( t(0j)==0)
     assert_( t(1j)==1)
     assert_( t(234)==1)
     assert_( t(234.6)==1)
     assert_( t(long(234))==1)
     assert_( t(234.6+3j)==1)
     assert_( t('234')==1)
     assert_( t('aaa')==1)
     assert_( t('')==0)
     assert_( t([])==0)
     assert_( t(())==0)
     assert_( t({})==0)
     assert_( t(t)==1)
     assert_( t(-234)==1)
     assert_( t(10**100)==1)
     assert_( t([234])==1)
     assert_( t((234,))==1)
     assert_( t(array(234))==1)
     assert_( t(array([234]))==1)
     assert_( t(array([[234]]))==1)
     assert_( t(array([234], 'b'))==1)
     assert_( t(array([234], 'h'))==1)
     assert_( t(array([234], 'i'))==1)
     assert_( t(array([234], 'l'))==1)
     assert_( t(array([234], 'f'))==1)
     assert_( t(array([234], 'd'))==1)
     assert_( t(array([234+3j], 'F'))==1)
     assert_( t(array([234], 'D'))==1)
     assert_( t(array(0))==0)
     assert_( t(array([0]))==0)
     assert_( t(array([[0]]))==0)
     assert_( t(array([0j]))==0)
     assert_( t(array([1]))==1)
     assert_raises(ValueError, t, array([0, 0]))
 def check_function(self, t):
     assert_(t(True) == 1, repr(t(True)))
     assert_(t(False) == 0, repr(t(False)))
     assert_(t(0) == 0)
     assert_(t(None) == 0)
     assert_(t(0.0) == 0)
     assert_(t(0j) == 0)
     assert_(t(1j) == 1)
     assert_(t(234) == 1)
     assert_(t(234.6) == 1)
     assert_(t(long(234)) == 1)
     assert_(t(234.6 + 3j) == 1)
     assert_(t('234') == 1)
     assert_(t('aaa') == 1)
     assert_(t('') == 0)
     assert_(t([]) == 0)
     assert_(t(()) == 0)
     assert_(t({}) == 0)
     assert_(t(t) == 1)
     assert_(t(-234) == 1)
     assert_(t(10**100) == 1)
     assert_(t([234]) == 1)
     assert_(t((234, )) == 1)
     assert_(t(array(234)) == 1)
     assert_(t(array([234])) == 1)
     assert_(t(array([[234]])) == 1)
     assert_(t(array([234], 'b')) == 1)
     assert_(t(array([234], 'h')) == 1)
     assert_(t(array([234], 'i')) == 1)
     assert_(t(array([234], 'l')) == 1)
     assert_(t(array([234], 'f')) == 1)
     assert_(t(array([234], 'd')) == 1)
     assert_(t(array([234 + 3j], 'F')) == 1)
     assert_(t(array([234], 'D')) == 1)
     assert_(t(array(0)) == 0)
     assert_(t(array([0])) == 0)
     assert_(t(array([[0]])) == 0)
     assert_(t(array([0j])) == 0)
     assert_(t(array([1])) == 1)
     assert_raises(ValueError, t, array([0, 0]))
Example #20
0
    def __new__(subtype, filename, dtype=uint8, mode='r+', offset=0,
                shape=None, order='C'):
        # Import here to minimize 'import numpy' overhead
        import mmap
        import os.path
        try:
            mode = mode_equivalents[mode]
        except KeyError:
            if mode not in valid_filemodes:
                raise ValueError("mode must be one of %s" %
                                 (valid_filemodes + list(mode_equivalents.keys())))

        if hasattr(filename, 'read'):
            fid = filename
            own_file = False
        elif is_pathlib_path(filename):
            fid = filename.open((mode == 'c' and 'r' or mode)+'b')
            own_file = True
        else:
            fid = open(filename, (mode == 'c' and 'r' or mode)+'b')
            own_file = True

        if (mode == 'w+') and shape is None:
            raise ValueError("shape must be given")

        fid.seek(0, 2)
        flen = fid.tell()
        descr = dtypedescr(dtype)
        _dbytes = descr.itemsize

        if shape is None:
            bytes = flen - offset
            if (bytes % _dbytes):
                fid.close()
                raise ValueError("Size of available data is not a "
                        "multiple of the data-type size.")
            size = bytes // _dbytes
            shape = (size,)
        else:
            if not isinstance(shape, tuple):
                shape = (shape,)
            size = 1
            for k in shape:
                size *= k

        bytes = long(offset + size*_dbytes)

        if mode == 'w+' or (mode == 'r+' and flen < bytes):
            fid.seek(bytes - 1, 0)
            fid.write(np.compat.asbytes('\0'))
            fid.flush()

        if mode == 'c':
            acc = mmap.ACCESS_COPY
        elif mode == 'r':
            acc = mmap.ACCESS_READ
        else:
            acc = mmap.ACCESS_WRITE

        start = offset - offset % mmap.ALLOCATIONGRANULARITY
        bytes -= start
        offset -= start
        mm = mmap.mmap(fid.fileno(), bytes, access=acc, offset=start)

        self = ndarray.__new__(subtype, shape, dtype=descr, buffer=mm,
            offset=offset, order=order)
        self._mmap = mm
        self.offset = offset
        self.mode = mode

        if isinstance(filename, basestring):
            self.filename = os.path.abspath(filename)
        elif is_pathlib_path(filename):
            self.filename = filename.resolve()
        # py3 returns int for TemporaryFile().name
        elif (hasattr(filename, "name") and
              isinstance(filename.name, basestring)):
            self.filename = os.path.abspath(filename.name)
        # same as memmap copies (e.g. memmap + 1)
        else:
            self.filename = None

        if own_file:
            fid.close()

        return self
 def test_permutation_longs(self):
     rnd.seed(1234, brng='MT19937')
     a = rnd.permutation(12)
     rnd.seed(1234, brng='MT19937')
     b = rnd.permutation(long(12))
     assert_array_equal(a, b)
 def test_permutation_longs(self):
     mt19937.seed(1234)
     a = mt19937.permutation(12)
     mt19937.seed(1234)
     b = mt19937.permutation(long(12))
     assert_array_equal(a, b)
Example #23
0
    def __new__(subtype, filename, dtype=uint8, mode='r+', offset=0,
                shape=None, order='C'):
        # Import here to minimize 'import numpy' overhead
        import mmap
        import os.path
        try:
            mode = mode_equivalents[mode]
        except KeyError:
            if mode not in valid_filemodes:
                raise ValueError("mode must be one of %s" %
                                 (valid_filemodes + list(mode_equivalents.keys())))

        if hasattr(filename,'read'):
            fid = filename
            own_file = False
        else:
            fid = open(filename, (mode == 'c' and 'r' or mode)+'b')
            own_file = True

        if (mode == 'w+') and shape is None:
            raise ValueError("shape must be given")

        fid.seek(0, 2)
        flen = fid.tell()
        descr = dtypedescr(dtype)
        _dbytes = descr.itemsize

        if shape is None:
            bytes = flen - offset
            if (bytes % _dbytes):
                fid.close()
                raise ValueError("Size of available data is not a "
                        "multiple of the data-type size.")
            size = bytes // _dbytes
            shape = (size,)
        else:
            if not isinstance(shape, tuple):
                shape = (shape,)
            size = 1
            for k in shape:
                size *= k

        bytes = long(offset + size*_dbytes)

        if mode == 'w+' or (mode == 'r+' and flen < bytes):
            fid.seek(bytes - 1, 0)
            fid.write(np.compat.asbytes('\0'))
            fid.flush()

        if mode == 'c':
            acc = mmap.ACCESS_COPY
        elif mode == 'r':
            acc = mmap.ACCESS_READ
        else:
            acc = mmap.ACCESS_WRITE

        if sys.version_info[:2] >= (2,6):
            # The offset keyword in mmap.mmap needs Python >= 2.6
            start = offset - offset % mmap.ALLOCATIONGRANULARITY
            bytes -= start
            offset -= start
            mm = mmap.mmap(fid.fileno(), bytes, access=acc, offset=start)
        else:
            mm = mmap.mmap(fid.fileno(), bytes, access=acc)

        self = ndarray.__new__(subtype, shape, dtype=descr, buffer=mm,
            offset=offset, order=order)
        self._mmap = mm
        self.offset = offset
        self.mode = mode

        if isinstance(filename, basestring):
            self.filename = os.path.abspath(filename)
        elif hasattr(filename, "name"):
            self.filename = os.path.abspath(filename.name)

        if own_file:
            fid.close()

        return self
 def test_permutation_longs(self):
     np.random.seed(1234)
     a = np.random.permutation(12)
     np.random.seed(1234)
     b = np.random.permutation(long(12))
     assert_array_equal(a, b)
Example #25
0
os.system(f'openssl rsa -pubin -text -modulus -in warmup -in public.key')

os.system(f'{rsa} --publickey public.key --private ')

os.system(f'{rsa} --publickey public.key --private --uncipherfile ./flag.enc')

os.system(f'{rsa} --dumpkey --key public.key')  # get n e,

### read n , e from key

from Crypto.PublicKey import RSA
from numpy.compat import long

public = RSA.importKey(open('public.key').read())
n = long(public.n)
e = long(public.e)
print(n)
print(e)


def factor(N):
    cmd = f"{yafu_path} factor({N})"
    cmd2 = f'start cmd /k {cmd}'
    os.system(cmd2)


def get_key(key):
    f = open('public.key', 'rb').read()
    pub = RSA.importKey(f)
    n = pub.n
Example #26
0
 def test_permutation_longs(self):
     rnd.seed(1234)
     a = rnd.permutation(12)
     rnd.seed(1234)
     b = rnd.permutation(long(12))
     assert_array_equal(a, b)
Example #27
0
    def __new__(subtype, filename, dtype=uint8, mode='r+', offset=0,
                shape=None, order='C'):
        # Import here to minimize 'import numpy' overhead
        import mmap
        import os.path
        try:
            mode = mode_equivalents[mode]
        except KeyError:
            if mode not in valid_filemodes:
                raise ValueError("mode must be one of %s" %
                                 (valid_filemodes + list(mode_equivalents.keys())))

        if mode == 'w+' and shape is None:
            raise ValueError("shape must be given")

        if hasattr(filename, 'read'):
            f_ctx = contextlib_nullcontext(filename)
        else:
            f_ctx = open(os_fspath(filename), ('r' if mode == 'c' else mode)+'b')

        with f_ctx as fid:
            fid.seek(0, 2)
            flen = fid.tell()
            descr = dtypedescr(dtype)
            _dbytes = descr.itemsize

            if shape is None:
                bytes = flen - offset
                if bytes % _dbytes:
                    raise ValueError("Size of available data is not a "
                            "multiple of the data-type size.")
                size = bytes // _dbytes
                shape = (size,)
            else:
                if not isinstance(shape, tuple):
                    shape = (shape,)
                size = np.intp(1)  # avoid default choice of np.int_, which might overflow
                for k in shape:
                    size *= k

            bytes = long(offset + size*_dbytes)

            if mode == 'w+' or (mode == 'r+' and flen < bytes):
                fid.seek(bytes - 1, 0)
                fid.write(b'\0')
                fid.flush()

            if mode == 'c':
                acc = mmap.ACCESS_COPY
            elif mode == 'r':
                acc = mmap.ACCESS_READ
            else:
                acc = mmap.ACCESS_WRITE

            start = offset - offset % mmap.ALLOCATIONGRANULARITY
            bytes -= start
            array_offset = offset - start
            mm = mmap.mmap(fid.fileno(), bytes, access=acc, offset=start)

            self = ndarray.__new__(subtype, shape, dtype=descr, buffer=mm,
                                   offset=array_offset, order=order)
            self._mmap = mm
            self.offset = offset
            self.mode = mode

            if is_pathlib_path(filename):
                # special case - if we were constructed with a pathlib.path,
                # then filename is a path object, not a string
                self.filename = filename.resolve()
            elif hasattr(fid, "name") and isinstance(fid.name, basestring):
                # py3 returns int for TemporaryFile().name
                self.filename = os.path.abspath(fid.name)
            # same as memmap copies (e.g. memmap + 1)
            else:
                self.filename = None

        return self
 def test_permutation_longs(self):
     mt19937 = Generator(MT19937(1234))
     a = mt19937.permutation(12)
     mt19937 = Generator(MT19937(1234))
     b = mt19937.permutation(long(12))
     assert_array_equal(a, b)
Example #29
0
    def __new__(subtype,
                filename,
                dtype=uint8,
                mode="r+",
                offset=0,
                shape=None,
                order="C"):
        # Import here to minimize 'import numpy' overhead
        import mmap
        import os.path

        try:
            mode = mode_equivalents[mode]
        except KeyError:
            if mode not in valid_filemodes:
                raise ValueError(
                    "mode must be one of %s" %
                    (valid_filemodes + list(mode_equivalents.keys())))

        if mode == "w+" and shape is None:
            raise ValueError("shape must be given")

        if hasattr(filename, "read"):
            f_ctx = contextlib_nullcontext(filename)
        else:
            f_ctx = open(os_fspath(filename),
                         ("r" if mode == "c" else mode) + "b")

        with f_ctx as fid:
            fid.seek(0, 2)
            flen = fid.tell()
            descr = dtypedescr(dtype)
            _dbytes = descr.itemsize

            if shape is None:
                bytes = flen - offset
                if bytes % _dbytes:
                    raise ValueError("Size of available data is not a "
                                     "multiple of the data-type size.")
                size = bytes // _dbytes
                shape = (size, )
            else:
                if not isinstance(shape, tuple):
                    shape = (shape, )
                size = np.intp(
                    1)  # avoid default choice of np.int_, which might overflow
                for k in shape:
                    size *= k

            bytes = long(offset + size * _dbytes)

            if mode == "w+" or (mode == "r+" and flen < bytes):
                fid.seek(bytes - 1, 0)
                fid.write(b"\0")
                fid.flush()

            if mode == "c":
                acc = mmap.ACCESS_COPY
            elif mode == "r":
                acc = mmap.ACCESS_READ
            else:
                acc = mmap.ACCESS_WRITE

            start = offset - offset % mmap.ALLOCATIONGRANULARITY
            bytes -= start
            array_offset = offset - start
            mm = mmap.mmap(fid.fileno(), bytes, access=acc, offset=start)

            self = ndarray.__new__(subtype,
                                   shape,
                                   dtype=descr,
                                   buffer=mm,
                                   offset=array_offset,
                                   order=order)
            self._mmap = mm
            self.offset = offset
            self.mode = mode

            if is_pathlib_path(filename):
                # special case - if we were constructed with a pathlib.path,
                # then filename is a path object, not a string
                self.filename = filename.resolve()
            elif hasattr(fid, "name") and isinstance(fid.name, basestring):
                # py3 returns int for TemporaryFile().name
                self.filename = os.path.abspath(fid.name)
            # same as memmap copies (e.g. memmap + 1)
            else:
                self.filename = None

        return self
 def test_permutation_longs(self):
     np.random.seed(1234)
     a = np.random.permutation(12)
     np.random.seed(1234)
     b = np.random.permutation(long(12))
     assert_array_equal(a, b)
Example #31
0
    def __new__(subtype,
                filename,
                dtype=uint8,
                mode='r+',
                offset=0,
                shape=None,
                order='C'):
        # Import here to minimize 'import numpy' overhead
        import mmap
        import os.path
        try:
            mode = mode_equivalents[mode]
        except KeyError:
            if mode not in valid_filemodes:
                raise ValueError(
                    "mode must be one of %s" %
                    (valid_filemodes + list(mode_equivalents.keys())))

        if hasattr(filename, 'read'):
            fid = filename
            own_file = False
        elif is_pathlib_path(filename):
            fid = filename.open((mode == 'c' and 'r' or mode) + 'b')
            own_file = True
        else:
            fid = open(filename, (mode == 'c' and 'r' or mode) + 'b')
            own_file = True

        if (mode == 'w+') and shape is None:
            raise ValueError("shape must be given")

        fid.seek(0, 2)
        flen = fid.tell()
        descr = dtypedescr(dtype)
        _dbytes = descr.itemsize

        if shape is None:
            bytes = flen - offset
            if (bytes % _dbytes):
                fid.close()
                raise ValueError("Size of available data is not a "
                                 "multiple of the data-type size.")
            size = bytes // _dbytes
            shape = (size, )
        else:
            if not isinstance(shape, tuple):
                shape = (shape, )
            size = np.intp(
                1)  # avoid default choice of np.int_, which might overflow
            for k in shape:
                size *= k

        bytes = long(offset + size * _dbytes)

        if mode == 'w+' or (mode == 'r+' and flen < bytes):
            fid.seek(bytes - 1, 0)
            fid.write(b'\0')
            fid.flush()

        if mode == 'c':
            acc = mmap.ACCESS_COPY
        elif mode == 'r':
            acc = mmap.ACCESS_READ
        else:
            acc = mmap.ACCESS_WRITE

        start = offset - offset % mmap.ALLOCATIONGRANULARITY
        bytes -= start
        array_offset = offset - start
        mm = mmap.mmap(fid.fileno(), bytes, access=acc, offset=start)

        self = ndarray.__new__(subtype,
                               shape,
                               dtype=descr,
                               buffer=mm,
                               offset=array_offset,
                               order=order)
        self._mmap = mm
        self.offset = offset
        self.mode = mode

        if isinstance(filename, basestring):
            self.filename = os.path.abspath(filename)
        elif is_pathlib_path(filename):
            self.filename = filename.resolve()
        # py3 returns int for TemporaryFile().name
        elif (hasattr(filename, "name")
              and isinstance(filename.name, basestring)):
            self.filename = os.path.abspath(filename.name)
        # same as memmap copies (e.g. memmap + 1)
        else:
            self.filename = None

        if own_file:
            fid.close()

        return self
 def test_permutation_longs(self):
     mt19937.seed(1234)
     a = mt19937.permutation(12)
     mt19937.seed(1234)
     b = mt19937.permutation(long(12))
     assert_array_equal(a, b)