예제 #1
0
    def testIsCloseExecution(self):
        data = np.array([1.05, 1.0, 1.01, np.nan])
        data2 = np.array([1.04, 1.0, 1.03, np.nan])

        x = tensor(data, chunk_size=2)
        y = tensor(data2, chunk_size=3)

        z = isclose(x, y, atol=.01)

        res = self.executor.execute_tensor(z, concat=True)[0]
        expected = np.isclose(data, data2, atol=.01)

        np.testing.assert_equal(res, expected)

        z = isclose(x, y, atol=.01, equal_nan=True)

        res = self.executor.execute_tensor(z, concat=True)[0]
        expected = np.isclose(data, data2, atol=.01, equal_nan=True)

        np.testing.assert_equal(res, expected)

        # test sparse

        data = sps.csr_matrix(np.array([0, 1.0, 1.01, np.nan]))
        data2 = sps.csr_matrix(np.array([0, 1.0, 1.03, np.nan]))

        x = tensor(data, chunk_size=2)
        y = tensor(data2, chunk_size=3)

        z = isclose(x, y, atol=.01)

        res = self.executor.execute_tensor(z, concat=True)[0]
        expected = np.isclose(data.toarray(), data2.toarray(), atol=.01)

        np.testing.assert_equal(res, expected)

        z = isclose(x, y, atol=.01, equal_nan=True)

        res = self.executor.execute_tensor(z, concat=True)[0]
        expected = np.isclose(data.toarray(),
                              data2.toarray(),
                              atol=.01,
                              equal_nan=True)

        np.testing.assert_equal(res, expected)
예제 #2
0
    def testIsclose(self):
        t1 = ones((2, 3), dtype='f4', chunk_size=2)

        atol = 1e-4
        rtol = 1e-5
        equal_nan = True

        t = isclose(t1, 2, atol=atol, rtol=rtol, equal_nan=equal_nan)

        self.assertIsInstance(t.op, TensorIsclose)
        self.assertEqual(t.op.atol, atol)
        self.assertEqual(t.op.rtol, rtol)
        self.assertEqual(t.op.equal_nan, equal_nan)

        t.tiles()

        self.assertIsInstance(t.chunks[0].op, TensorIsclose)
        self.assertEqual(t.chunks[0].op.atol, atol)
        self.assertEqual(t.chunks[0].op.rtol, rtol)
        self.assertEqual(t.chunks[0].op.equal_nan, equal_nan)

        t1 = ones((2, 3), dtype='f4', chunk_size=2)
        t2 = ones((2, 3), dtype='f4', chunk_size=2)

        atol = 1e-4
        rtol = 1e-5
        equal_nan = True

        t = isclose(t1, t2, atol=atol, rtol=rtol, equal_nan=equal_nan)

        self.assertIsInstance(t.op, TensorIsclose)
        self.assertEqual(t.op.atol, atol)
        self.assertEqual(t.op.rtol, rtol)
        self.assertEqual(t.op.equal_nan, equal_nan)

        t.tiles()

        self.assertIsInstance(t.chunks[0].op, TensorIsclose)
        self.assertEqual(t.chunks[0].op.atol, atol)
        self.assertEqual(t.chunks[0].op.rtol, rtol)
        self.assertEqual(t.chunks[0].op.equal_nan, equal_nan)
예제 #3
0
def test_isclose():
    t1 = ones((2, 3), dtype='f4', chunk_size=2)

    atol = 1e-4
    rtol = 1e-5
    equal_nan = True

    t = isclose(t1, 2, atol=atol, rtol=rtol, equal_nan=equal_nan)

    assert isinstance(t.op, TensorIsclose)
    assert t.op.atol == atol
    assert t.op.rtol == rtol
    assert t.op.equal_nan == equal_nan

    t = tile(t)

    assert isinstance(t.chunks[0].op, TensorIsclose)
    assert t.chunks[0].op.atol == atol
    assert t.chunks[0].op.rtol == rtol
    assert t.chunks[0].op.equal_nan == equal_nan

    t1 = ones((2, 3), dtype='f4', chunk_size=2)
    t2 = ones((2, 3), dtype='f4', chunk_size=2)

    atol = 1e-4
    rtol = 1e-5
    equal_nan = True

    t = isclose(t1, t2, atol=atol, rtol=rtol, equal_nan=equal_nan)

    assert isinstance(t.op, TensorIsclose)
    assert t.op.atol == atol
    assert t.op.rtol == rtol
    assert t.op.equal_nan == equal_nan

    t = tile(t)

    assert isinstance(t.chunks[0].op, TensorIsclose)
    assert t.chunks[0].op.atol == atol
    assert t.chunks[0].op.rtol == rtol
    assert t.chunks[0].op.equal_nan == equal_nan
예제 #4
0
def test_is_close_execution(setup):
    data = np.array([1.05, 1.0, 1.01, np.nan])
    data2 = np.array([1.04, 1.0, 1.03, np.nan])

    x = tensor(data, chunk_size=2)
    y = tensor(data2, chunk_size=3)

    z = isclose(x, y, atol=.01)

    res = z.execute().fetch()
    expected = np.isclose(data, data2, atol=.01)
    np.testing.assert_equal(res, expected)

    z = isclose(x, y, atol=.01, equal_nan=True)

    res = z.execute().fetch()
    expected = np.isclose(data, data2, atol=.01, equal_nan=True)
    np.testing.assert_equal(res, expected)

    # test tensor with scalar
    z = isclose(x, 1.0, atol=.01)
    res = z.execute().fetch()
    expected = np.isclose(data, 1.0, atol=.01)
    np.testing.assert_equal(res, expected)
    z = isclose(1.0, y, atol=.01)
    res = z.execute().fetch()
    expected = np.isclose(1.0, data2, atol=.01)
    np.testing.assert_equal(res, expected)
    z = isclose(1.0, 2.0, atol=.01)
    res = z.execute().fetch()
    expected = np.isclose(1.0, 2.0, atol=.01)
    np.testing.assert_equal(res, expected)

    # test sparse
    data = sps.csr_matrix(np.array([0, 1.0, 1.01, np.nan]))
    data2 = sps.csr_matrix(np.array([0, 1.0, 1.03, np.nan]))

    x = tensor(data, chunk_size=2)
    y = tensor(data2, chunk_size=3)

    z = isclose(x, y, atol=.01)

    res = z.execute().fetch()
    expected = np.isclose(data.toarray(), data2.toarray(), atol=.01)
    np.testing.assert_equal(res, expected)

    z = isclose(x, y, atol=.01, equal_nan=True)

    res = z.execute().fetch()
    expected = np.isclose(data.toarray(),
                          data2.toarray(),
                          atol=.01,
                          equal_nan=True)
    np.testing.assert_equal(res, expected)