Esempio n. 1
0
    def test_va(self):
        self.start()

        self.assertEqual(gxva.__version__, geosoft.__version__)

        with gxva.GXva(width=12, dtype=np.float) as va:
            self.assertTrue(isinstance(va.gxva, gxapi.GXVA))
            self.assertEqual(va.fid, (0.0, 1.0))
            self.assertEqual(va.width, 12)

        fid = (10.1, 0.99)
        with gxva.GXva(width=7, dtype=np.float, fid=fid) as va:
            self.assertEqual(va.fid, fid)
            self.assertEqual(va.width, 7)

            fid = (-45, 7)
            va.fid = fid
            self.assertEqual(va.fid, fid)

            va.refid((-40, 8), 4)
            self.assertEqual(va.fid, (-40, 8))
            self.assertEqual(va.length, 4)
            self.assertEqual(va.dimensions, (4, 7))
            self.assertEqual(va.gxtype, gxu.gx_dtype(np.float))
            self.assertEqual(va.np.shape, (4, 7))

            va.length = 16
            self.assertEqual(va.fid, (-40, 8))
            self.assertEqual(va.length, 16)
            self.assertEqual(va.dimensions, (16, 7))
            self.assertEqual(va.gxtype, gxu.gx_dtype(np.float))
            self.assertEqual(va.np.shape, (16, 7))
Esempio n. 2
0
    def test_vv(self):
        self.start(gsys.func_name())

        self.assertEqual(gxvv.__version__, geosoft.__version__)

        with gxvv.GXvv(dtype=np.float) as vv:
            self.assertEqual(vv.fid, (0.0, 1.0))

        fid = (10.1, 0.99)
        with gxvv.GXvv(dtype=np.float, fid=fid) as vv:
            self.assertEqual(vv.fid, fid)
            self.assertEqual(vv.length, 0)

            fid = (-45, 7)
            vv.fid = fid
            self.assertEqual(vv.fid, fid)

            vv.reFid((-40, 8), 4)
            self.assertEqual(vv.fid, (-40, 8))
            self.assertEqual(vv.length, 4)

        with gxvv.GXvv([1, 2, 3, 4, 5, 6]) as vv:
            self.assertEqual(vv.fid, (0.0, 1.0))
            self.assertEqual(vv.length, 6)
            self.assertEqual(vv.dtype, np.int32)
            self.assertEqual(vv.gxtype, gxu.gx_dtype(np.int32))

        with gxvv.GXvv([1, 2, 3, 4, 5, 6], dtype=np.int64) as vv:
            self.assertEqual(vv.fid, (0.0, 1.0))
            self.assertEqual(vv.length, 6)
            self.assertEqual(vv.dtype, np.int64)
            self.assertEqual(vv.gxtype, gxu.gx_dtype(np.int64))
Esempio n. 3
0
    def test_vv(self):
        self.start()

        self.assertEqual(gxvv.__version__, geosoft.__version__)

        with gxvv.GXvv(dtype=np.float) as vv:
            self.assertTrue(vv.gxvv, gxapi.GXVV)
            self.assertEqual(vv.fid, (0.0, 1.0))

        fid = (10.1, 0.99)
        with gxvv.GXvv(dtype=np.float, fid=fid) as vv:
            self.assertTrue(vv.is_float)
            self.assertFalse(vv.is_int)
            self.assertFalse(vv.is_string)
            self.assertEqual(vv.fid, fid)
            self.assertEqual(vv.length, 0)

            fid = (-45, 7)
            vv.fid = fid
            self.assertEqual(vv.fid, fid)

            vv.refid((-40, 8), 4)
            self.assertEqual(vv.fid, (-40, 8))
            self.assertEqual(vv.length, 4)
            self.assertEqual(len(vv.np), 4)

            vv.length = 16
            self.assertEqual(vv.fid, (-40, 8))
            self.assertEqual(vv.length, 16)
            self.assertEqual(len(vv.np), 16)
            self.assertEqual(vv.dim, 1)

            vv.refid((-38, 1.5))
            self.assertEqual(vv.fid, (-38, 1.5))
            self.assertEqual(vv.length, 80)

            vv.refid((1000, 50))
            self.assertEqual(vv.fid, (1000., 50.))
            self.assertEqual(vv.length, 0)

            self.assertRaises(gxvv.VVException, vv.refid, (1, 0))
            self.assertRaises(gxvv.VVException, vv.refid, (1, -1))

        with gxvv.GXvv([1, 2, 3, 4, 5, 6]) as vv:
            self.assertTrue(vv.is_int)
            self.assertFalse(vv.is_float)
            self.assertFalse(vv.is_string)

            self.assertEqual(vv.fid, (0.0, 1.0))
            self.assertEqual(vv.length, 6)
            self.assertEqual(vv.dtype, np.int32)
            self.assertEqual(vv.gxtype, gxu.gx_dtype(np.int32))

        with gxvv.GXvv([1, 2, 3, 4, 5, 6], dtype=np.int64) as vv:
            self.assertEqual(vv.fid, (0.0, 1.0))
            self.assertEqual(vv.length, 6)
            self.assertEqual(vv.dtype, np.int64)
            self.assertEqual(vv.gxtype, gxu.gx_dtype(np.int64))
Esempio n. 4
0
    def test_va(self):
        self.start(gsys.func_name())

        self.assertEqual(gxva.__version__, geosoft.__version__)

        with gxva.GXva(width=12, dtype=np.float) as va:
            self.assertEqual(va.fid, (0.0,1.0))
            self.assertEqual(va.width, 12)

        fid = (10.1,0.99)
        with gxva.GXva(width=7, dtype=np.float, fid=fid) as va:
            self.assertEqual(va.fid, fid)
            self.assertEqual(va.width, 7)

            fid = (-45,7)
            va.fid = fid
            self.assertEqual(va.fid,fid)

            va.reFid((-40,8),4)
            self.assertEqual(va.fid,(-40,8))
            self.assertEqual(va.length,4)
            self.assertEqual(va.dimensions, (4,7))
            self.assertEqual(va.gxtype, gxu.gx_dtype(np.float))
Esempio n. 5
0
    def test_misc(self):
        self.start()

        self.assertEqual(gxu.__version__, geosoft.__version__)

        self.assertEqual(gxu.gx_dtype('float'), gxapi.GS_DOUBLE)
        self.assertEqual(gxu.gx_dtype('int'), gxapi.GS_LONG)
        self.assertEqual(gxu.gx_dtype("<U18"),
                         -72)  # x4 for full range of UTF-8 characters
        self.assertEqual(gxu.gx_dtype('uint64'), gxapi.GS_ULONG64)

        self.assertEqual(gxu.dtype_gx(gxapi.GS_DOUBLE), np.float)
        self.assertEqual(gxu.dtype_gx(gxapi.GS_FLOAT), np.float32)
        self.assertEqual(gxu.dtype_gx(gxapi.GS_LONG), np.int32)
        self.assertEqual(gxu.dtype_gx(-2000).str, "<U2000")
        self.assertEqual(gxu.dtype_gx(gxapi.GS_ULONG64), np.uint64)

        self.assertEqual(gxu.gx_dummy(np.float), gxapi.rDUMMY)
        self.assertEqual(gxu.gx_dummy(np.int32), gxapi.iDUMMY)
        self.assertEqual(gxu.gx_dummy(np.int64), gxapi.GS_S8DM)
        self.assertEqual(gxu.gx_dummy(np.str_), '')
        self.assertEqual(gxu.gx_dummy('U48'), '')

        self.assertEqual(gxu.gx_dummy(np.uint), gxapi.GS_U4DM)
        self.assertEqual(gxu.gx_dummy(np.uint8), gxapi.GS_U1DM)
        self.assertEqual(gxu.gx_dummy(np.uint16), gxapi.GS_U2DM)
        self.assertEqual(gxu.gx_dummy(np.uint32), gxapi.GS_U4DM)
        self.assertEqual(gxu.gx_dummy(np.uint64), gxapi.GS_U8DM)

        self.assertEqual(gxu.gx_dummy(1.5), gxapi.rDUMMY)
        self.assertEqual(gxu.gx_dummy(type(1.5)), gxapi.rDUMMY)
        self.assertEqual(gxu.gx_dummy(3), gxapi.iDUMMY)
        self.assertEqual(gxu.gx_dummy(type(3)), gxapi.iDUMMY)
        self.assertEqual(gxu.gx_dummy(0xff), gxapi.iDUMMY)
        self.assertEqual(gxu.gx_dummy('string'), '')
        self.assertEqual(gxu.gx_dummy('U48'), '')
        self.assertRaises(KeyError, gxu.gx_dummy, 1j)
        self.assertRaises(KeyError, gxu.gx_dummy, type(1j))

        self.assertEqual(gxu.dummy_none(0), 0)
        self.assertEqual(gxu.dummy_none(1.), 1.)
        self.assertEqual(gxu.dummy_none(gxapi.iDUMMY), None)
        self.assertEqual(gxu.dummy_none(gxapi.rDUMMY), None)

        self.assertTrue(gxu.is_float(gxu.gx_dtype('float')))
        self.assertFalse(gxu.is_int(gxu.gx_dtype('float')))
        self.assertTrue(gxu.is_int(gxu.gx_dtype('uint64')))
        self.assertFalse(gxu.is_float(gxu.gx_dtype('uint64')))
        self.assertTrue(gxu.is_string(gxu.gx_dtype('U18')))
        self.assertFalse(gxu.is_int(gxu.gx_dtype('U18')))
        self.assertFalse(gxu.is_float(gxu.gx_dtype('U18')))
        self.assertEqual(gxu.is_string(gxu.gx_dtype('U18')), 72)

        self.assertEqual(gxu.dtype_gx_dimension(gxapi.GS_FLOAT),
                         (np.float32, 1))
        self.assertEqual(gxu.dtype_gx_dimension(gxapi.GS_FLOAT2D),
                         (np.float32, 2))
        self.assertEqual(gxu.dtype_gx_dimension(gxapi.GS_FLOAT3D),
                         (np.float32, 3))
        self.assertEqual(gxu.dtype_gx_dimension(gxapi.GS_DOUBLE),
                         (np.float64, 1))
        self.assertEqual(gxu.dtype_gx_dimension(gxapi.GS_DOUBLE2D),
                         (np.float64, 2))
        self.assertEqual(gxu.dtype_gx_dimension(gxapi.GS_DOUBLE3D),
                         (np.float64, 3))

        self.assertEqual(gxu.gx_dtype_dimension(np.float32), gxapi.GS_FLOAT)
        self.assertEqual(gxu.gx_dtype_dimension(np.float32, 1), gxapi.GS_FLOAT)
        self.assertEqual(gxu.gx_dtype_dimension(np.float32, 2),
                         gxapi.GS_FLOAT2D)
        self.assertEqual(gxu.gx_dtype_dimension(np.float32, 3),
                         gxapi.GS_FLOAT3D)
        self.assertEqual(gxu.gx_dtype_dimension(np.float64), gxapi.GS_DOUBLE)
        self.assertEqual(gxu.gx_dtype_dimension(np.float64, 1),
                         gxapi.GS_DOUBLE)
        self.assertEqual(gxu.gx_dtype_dimension(np.float64, 2),
                         gxapi.GS_DOUBLE2D)
        self.assertEqual(gxu.gx_dtype_dimension(np.float64, 3),
                         gxapi.GS_DOUBLE3D)

        self.assertRaises(gxu.UtilityException, gxu.gx_dtype_dimension, np.int,
                          2)
        self.assertRaises(gxu.UtilityException, gxu.gx_dtype_dimension, np.int,
                          3)
        self.assertRaises(gxu.UtilityException, gxu.gx_dtype_dimension,
                          np.float32, 4)

        npd = np.array([[1, 1], [2, 2], [-127, 1], [3, 3]],
                       dtype=gxu.dtype_gx(gxapi.GS_BYTE))
        self.assertEqual(list(gxu.dummy_mask(npd)),
                         [False, False, True, False])

        npd = np.array([1, 2, 3, 4], dtype=gxu.dtype_gx(gxapi.GS_BYTE))
        try:
            gxu.dummy_mask(npd)
            self.assertTrue(False)
        except:
            pass
Esempio n. 6
0
    def test_misc(self):
        self.start(gsys.func_name())

        self.assertEqual(gxu.__version__, geosoft.__version__)

        self.assertEqual(gxu.gx_dtype('float'), gxapi.GS_DOUBLE)
        self.assertEqual(gxu.gx_dtype('int'), gxapi.GS_LONG)
        self.assertEqual(gxu.gx_dtype("<U18"), -18)
        self.assertEqual(gxu.gx_dtype('uint64'), gxapi.GS_ULONG64)

        self.assertEqual(gxu.dtype_gx(gxapi.GS_DOUBLE), np.float)
        self.assertEqual(gxu.dtype_gx(gxapi.GS_FLOAT), np.float32)
        self.assertEqual(gxu.dtype_gx(gxapi.GS_LONG), np.int32)
        self.assertEqual(gxu.dtype_gx(-2000).str, "<U2000")
        self.assertEqual(gxu.dtype_gx(gxapi.GS_TYPE_DEFAULT), None)
        self.assertEqual(gxu.dtype_gx(gxapi.GS_ULONG64), np.uint64)

        self.assertEqual(gxu.gx_dummy(np.float), gxapi.rDUMMY)
        self.assertEqual(gxu.gx_dummy(np.int32), gxapi.iDUMMY)
        self.assertEqual(gxu.gx_dummy(np.int64), gxapi.GS_S8DM)
        self.assertEqual(gxu.gx_dummy(np.str_), '')
        self.assertEqual(gxu.gx_dummy('U48'), '')

        self.assertTrue(gxu.is_float(gxu.gx_dtype('float')))
        self.assertFalse(gxu.is_int(gxu.gx_dtype('float')))
        self.assertTrue(gxu.is_int(gxu.gx_dtype('uint64')))
        self.assertFalse(gxu.is_float(gxu.gx_dtype('uint64')))
        self.assertTrue(gxu.is_string(gxu.gx_dtype('U18')))
        self.assertFalse(gxu.is_int(gxu.gx_dtype('U18')))
        self.assertFalse(gxu.is_float(gxu.gx_dtype('U18')))
        self.assertEqual(gxu.is_string(gxu.gx_dtype('U18')), 18)

        npd = np.array([[1, 1], [2, 2], [-127, 1], [3, 3]],
                       dtype=gxu.dtype_gx(gxapi.GS_BYTE))
        self.assertEqual(list(gxu.dummy_mask(npd)),
                         [False, False, True, False])

        npd = np.array([1, 2, 3, 4], dtype=gxu.dtype_gx(gxapi.GS_BYTE))
        try:
            gxu.dummy_mask(npd)
            self.assertTrue(False)
        except:
            pass