Пример #1
0
    def test_legacy_mode_scalars(self):
        # in legacy mode, str of floats get truncated, and complex scalars
        # use * for non-finite imaginary part
        np.set_printoptions(legacy='1.13')
        assert_equal(str(np.float64(1.123456789123456789)), '1.12345678912')
        assert_equal(str(np.complex128(complex(1, np.nan))), '(1+nan*j)')

        np.set_printoptions(legacy=False)
        assert_equal(str(np.float64(1.123456789123456789)),
                     '1.1234567891234568')
        assert_equal(str(np.complex128(complex(1, np.nan))), '(1+nanj)')
Пример #2
0
    def test_non_integer_argument_errors(self):
        a = np.array([[5]])

        assert_raises(TypeError, np.reshape, a, (1., 1., -1))
        assert_raises(TypeError, np.reshape, a, (np.array(1.), -1))
        assert_raises(TypeError, np.take, a, [0], 1.)
        assert_raises(TypeError, np.take, a, [0], np.float64(1.))
Пример #3
0
    def test_scalar(self):
        x = np.inf
        actual = np.isposinf(x)
        expected = np.True_
        assert_equal(actual, expected)
        assert_equal(type(actual), type(expected))

        x = -3.4
        actual = np.fix(x)
        expected = np.float64(-3.0)
        assert_equal(actual, expected)
        assert_equal(type(actual), type(expected))

        out = np.array(0.0)
        actual = np.fix(x, out=out)
        assert_(actual is out)
Пример #4
0
 def check(v):
     # we compare str to repr, to avoid python2 truncation behavior
     assert_equal(str(np.float64(v)), repr(v))
     assert_equal(repr(np.float64(v)), repr(v))
Пример #5
0
 def float64_vs_python(self):
     # gh-2643, gh-6136, gh-6908
     assert_equal(repr(np.float64(0.1)), repr(0.1))
     assert_(repr(np.float64(0.20000000000000004)) != repr(0.2))
Пример #6
0
    def test_dragon4(self):
        # these tests are adapted from Ryan Juckett's dragon4 implementation,
        # see dragon4.c for details.

        fpos32 = lambda x, **k: np.format_float_positional(np.float32(x), **k)
        fsci32 = lambda x, **k: np.format_float_scientific(np.float32(x), **k)
        fpos64 = lambda x, **k: np.format_float_positional(np.float64(x), **k)
        fsci64 = lambda x, **k: np.format_float_scientific(np.float64(x), **k)

        preckwd = lambda prec: {'unique': False, 'precision': prec}

        assert_equal(fpos32('1.0'), "1.")
        assert_equal(fsci32('1.0'), "1.e+00")
        assert_equal(fpos32('10.234'), "10.234")
        assert_equal(fpos32('-10.234'), "-10.234")
        assert_equal(fsci32('10.234'), "1.0234e+01")
        assert_equal(fsci32('-10.234'), "-1.0234e+01")
        assert_equal(fpos32('1000.0'), "1000.")
        assert_equal(fpos32('1.0', precision=0), "1.")
        assert_equal(fsci32('1.0', precision=0), "1.e+00")
        assert_equal(fpos32('10.234', precision=0), "10.")
        assert_equal(fpos32('-10.234', precision=0), "-10.")
        assert_equal(fsci32('10.234', precision=0), "1.e+01")
        assert_equal(fsci32('-10.234', precision=0), "-1.e+01")
        assert_equal(fpos32('10.234', precision=2), "10.23")
        assert_equal(fsci32('-10.234', precision=2), "-1.02e+01")
        assert_equal(fsci64('9.9999999999999995e-08', **preckwd(16)),
                     '9.9999999999999995e-08')
        assert_equal(fsci64('9.8813129168249309e-324', **preckwd(16)),
                     '9.8813129168249309e-324')
        assert_equal(fsci64('9.9999999999999694e-311', **preckwd(16)),
                     '9.9999999999999694e-311')

        # test rounding
        # 3.1415927410 is closest float32 to np.pi
        assert_equal(fpos32('3.14159265358979323846', **preckwd(10)),
                     "3.1415927410")
        assert_equal(fsci32('3.14159265358979323846', **preckwd(10)),
                     "3.1415927410e+00")
        assert_equal(fpos64('3.14159265358979323846', **preckwd(10)),
                     "3.1415926536")
        assert_equal(fsci64('3.14159265358979323846', **preckwd(10)),
                     "3.1415926536e+00")
        # 299792448 is closest float32 to 299792458
        assert_equal(fpos32('299792458.0', **preckwd(5)), "299792448.00000")
        assert_equal(fsci32('299792458.0', **preckwd(5)), "2.99792e+08")
        assert_equal(fpos64('299792458.0', **preckwd(5)), "299792458.00000")
        assert_equal(fsci64('299792458.0', **preckwd(5)), "2.99792e+08")

        assert_equal(fpos32('3.14159265358979323846', **preckwd(25)),
                     "3.1415927410125732421875000")
        assert_equal(fpos64('3.14159265358979323846', **preckwd(50)),
                     "3.14159265358979311599796346854418516159057617187500")
        assert_equal(fpos64('3.14159265358979323846'), "3.141592653589793")

        # smallest numbers
        assert_equal(
            fpos32(0.5**(126 + 23), unique=False, precision=149),
            "0.00000000000000000000000000000000000000000000140129846432"
            "4817070923729583289916131280261941876515771757068283889791"
            "08268586060148663818836212158203125")
        assert_equal(
            fpos64(0.5**(1022 + 52), unique=False, precision=1074),
            "0.00000000000000000000000000000000000000000000000000000000"
            "0000000000000000000000000000000000000000000000000000000000"
            "0000000000000000000000000000000000000000000000000000000000"
            "0000000000000000000000000000000000000000000000000000000000"
            "0000000000000000000000000000000000000000000000000000000000"
            "0000000000000000000000000000000000049406564584124654417656"
            "8792868221372365059802614324764425585682500675507270208751"
            "8652998363616359923797965646954457177309266567103559397963"
            "9877479601078187812630071319031140452784581716784898210368"
            "8718636056998730723050006387409153564984387312473397273169"
            "6151400317153853980741262385655911710266585566867681870395"
            "6031062493194527159149245532930545654440112748012970999954"
            "1931989409080416563324524757147869014726780159355238611550"
            "1348035264934720193790268107107491703332226844753335720832"
            "4319360923828934583680601060115061698097530783422773183292"
            "4790498252473077637592724787465608477820373446969953364701"
            "7972677717585125660551199131504891101451037862738167250955"
            "8373897335989936648099411642057026370902792427675445652290"
            "87538682506419718265533447265625")

        # largest numbers
        assert_equal(fpos32(np.finfo(np.float32).max, **preckwd(0)),
                     "340282346638528859811704183484516925440.")
        assert_equal(
            fpos64(np.finfo(np.float64).max, **preckwd(0)),
            "1797693134862315708145274237317043567980705675258449965989"
            "1747680315726078002853876058955863276687817154045895351438"
            "2464234321326889464182768467546703537516986049910576551282"
            "0762454900903893289440758685084551339423045832369032229481"
            "6580855933212334827479782620414472316873817718091929988125"
            "0404026184124858368.")
        # Warning: In unique mode only the integer digits necessary for
        # uniqueness are computed, the rest are 0. Should we change this?
        assert_equal(fpos32(np.finfo(np.float32).max, precision=0),
                     "340282350000000000000000000000000000000.")

        # test trailing zeros
        assert_equal(fpos32('1.0', unique=False, precision=3), "1.000")
        assert_equal(fpos64('1.0', unique=False, precision=3), "1.000")
        assert_equal(fsci32('1.0', unique=False, precision=3), "1.000e+00")
        assert_equal(fsci64('1.0', unique=False, precision=3), "1.000e+00")
        assert_equal(fpos32('1.5', unique=False, precision=3), "1.500")
        assert_equal(fpos64('1.5', unique=False, precision=3), "1.500")
        assert_equal(fsci32('1.5', unique=False, precision=3), "1.500e+00")
        assert_equal(fsci64('1.5', unique=False, precision=3), "1.500e+00")
        # gh-10713
        assert_equal(
            fpos64('324', unique=False, precision=5, fractional=False),
            "324.00")