def test_random_strings_lognormal_with_seed(self):
pda = ak.random_strings_lognormal(2, 0.25, 10, seed=1)
self.assertTrue((ak.array(['TVKJTE', 'ABOCORHFM', 'LUDMMGTB', 'KWOQNPHZ',
'VSXRRL', 'AKOZOEEWTB', 'GOSVGEJNOW', 'BFWSIO',
'MRIEJUSA', 'OLUKRJK'])
== pda).all())
pda = ak.random_strings_lognormal(float(2), np.float64(0.25), np.int64(10), seed=1)
self.assertTrue((ak.array(['TVKJTE', 'ABOCORHFM', 'LUDMMGTB', 'KWOQNPHZ',
'VSXRRL', 'AKOZOEEWTB', 'GOSVGEJNOW', 'BFWSIO',
'MRIEJUSA', 'OLUKRJK'])
== pda).all())
pda = ak.random_strings_lognormal(2, 0.25, 10, seed=1, characters='printable')
self.assertTrue((ak.array(['+5"fp-', ']3Q4kC~HF', '=F=`,IE!', "DjkBa'9(", '5oZ1)=',
'T^.1@6aj";', '8b2$IX!Y7.', 'x|Y!eQ', '>1\\>2,on', '&#W":C3'])
== pda).all())
pda = ak.random_strings_lognormal(np.int64(2), np.float64(0.25), np.int64(10), seed=1, characters='printable')
self.assertTrue((ak.array(['+5"fp-', ']3Q4kC~HF', '=F=`,IE!', "DjkBa'9(", '5oZ1)=',
'T^.1@6aj";', '8b2$IX!Y7.', 'x|Y!eQ', '>1\\>2,on', '&#W":C3'])
== pda).all())
def testSeededRNG(self):
N = 100
seed = 8675309
numericdtypes = [ak.int64, ak.float64, ak.bool]
for dt in numericdtypes:
# Make sure unseeded runs differ
a = ak.randint(0, 2**32, N, dtype=dt)
b = ak.randint(0, 2**32, N, dtype=dt)
self.assertFalse((a == b).all())
# Make sure seeded results are same
a = ak.randint(0, 2**32, N, dtype=dt, seed=seed)
b = ak.randint(0, 2**32, N, dtype=dt, seed=seed)
self.assertTrue((a == b).all())
# Uniform
self.assertFalse((ak.uniform(N) == ak.uniform(N)).all())
self.assertTrue((ak.uniform(N, seed=seed) == ak.uniform(N, seed=seed)).all())
# Standard Normal
self.assertFalse((ak.standard_normal(N) == ak.standard_normal(N)).all())
self.assertTrue((ak.standard_normal(N, seed=seed) == ak.standard_normal(N, seed=seed)).all())
# Strings (uniformly distributed length)
self.assertFalse((ak.random_strings_uniform(1, 10, N) == ak.random_strings_uniform(1, 10, N)).all())
self.assertTrue((ak.random_strings_uniform(1, 10, N, seed=seed) == ak.random_strings_uniform(1, 10, N, seed=seed)).all())
# Strings (log-normally distributed length)
self.assertFalse((ak.random_strings_lognormal(2, 1, N) == ak.random_strings_lognormal(2, 1, N)).all())
self.assertTrue((ak.random_strings_lognormal(2, 1, N, seed=seed) == ak.random_strings_lognormal(2, 1, N, seed=seed)).all())
def test_random_strings_lognormal(self):
pda = ak.random_strings_lognormal(2, 0.25, 100, characters='printable')
self.assertIsInstance(pda, ak.Strings)
self.assertEqual(100, len(pda))
self.assertEqual(str, pda.dtype)
with self.assertRaises(TypeError) as cm:
ak.random_strings_lognormal('2', 0.25, 100)
self.assertEqual(
'type of argument "logmean" must be one of (float, int); got str instead',
cm.exception.args[0])
with self.assertRaises(TypeError) as cm:
ak.random_strings_lognormal(2, 25, 100)
self.assertEqual("The logstd must be a float", cm.exception.args[0])
with self.assertRaises(TypeError) as cm:
ak.random_strings_lognormal(2, 0.25, '100')
self.assertEqual(
'type of argument "size" must be int; got str instead',
cm.exception.args[0])
with self.assertRaises(TypeError) as cm:
ak.random_strings_lognormal(2, 0.25, 100, 1000000)
self.assertEqual(
'type of argument "characters" must be str; got int instead',
cm.exception.args[0])
def setUp(self):
self.maxDiff = None
ArkoudaTest.setUp(self)
base_words1 = ak.random_strings_uniform(1,
10,
UNIQUE,
characters='printable')
base_words2 = ak.random_strings_lognormal(2,
0.25,
UNIQUE,
characters='printable')
gremlins = np.array(['"', ' ', ''])
self.gremlins = ak.array(gremlins)
self.base_words = ak.concatenate((base_words1, base_words2))
self.np_base_words = np.hstack(
(base_words1.to_ndarray(), base_words2.to_ndarray()))
choices = ak.randint(0, self.base_words.size, N)
self.strings = self.base_words[choices]
self.test_strings = self.strings.to_ndarray()
self.cat = ak.Categorical(self.strings)
x, w = tuple(
zip(*Counter(''.join(self.base_words.to_ndarray())).items()))
self.delim = self._get_delimiter(x, w, gremlins)
self.akset = set(ak.unique(self.strings).to_ndarray())
self.gremlins_base_words = ak.concatenate(
(self.base_words, self.gremlins))
self.gremlins_strings = ak.concatenate(
(self.base_words[choices], self.gremlins))
self.gremlins_test_strings = self.gremlins_strings.to_ndarray()
self.gremlins_cat = ak.Categorical(self.gremlins_strings)
def setUp(self):
ArkoudaTest.setUp(self)
base_words1 = ak.random_strings_uniform(1,
10,
UNIQUE,
characters='printable')
base_words2 = ak.random_strings_lognormal(2,
0.25,
UNIQUE,
characters='printable')
base_sas1 = ak.suffix_array(base_words1)
base_sas2 = ak.suffix_array(base_words2)
'''
def test_random_strings_lognormal(self):
pda = ak.random_strings_lognormal(2, 0.25, 100, characters='printable')
self.assertIsInstance(pda,ak.Strings)
self.assertEqual(100, len(pda))
self.assertEqual(str, pda.dtype)
pda = ak.random_strings_lognormal(np.int64(2), 0.25, np.int64(100), characters='printable')
self.assertIsInstance(pda,ak.Strings)
self.assertEqual(100, len(pda))
self.assertEqual(str, pda.dtype)
pda = ak.random_strings_lognormal(np.int64(2), 0.25, np.int64(100), characters='printable',
seed=np.int64(0))
self.assertIsInstance(pda,ak.Strings)
self.assertEqual(100, len(pda))
self.assertEqual(str, pda.dtype)
pda = ak.random_strings_lognormal(np.float64(2), np.float64(0.25), np.int64(100),
characters='printable', seed=np.int64(0))
self.assertIsInstance(pda,ak.Strings)
self.assertEqual(100, len(pda))
self.assertEqual(str, pda.dtype)
with self.assertRaises(TypeError) as cm:
ak.random_strings_lognormal('2', 0.25, 100)
self.assertEqual('both logmean and logstd must be an int, np.int64, float, or np.float64',
cm.exception.args[0])
with self.assertRaises(TypeError) as cm:
ak.random_strings_lognormal(2, 0.25, '100')
self.assertEqual('type of argument "size" must be one of (int, int64); got str instead',
cm.exception.args[0])
with self.assertRaises(TypeError) as cm:
ak.random_strings_lognormal(2, 0.25, 100, 1000000)
self.assertEqual('type of argument "characters" must be str; got int instead',
cm.exception.args[0])
def test_random_strings_lognormal(self):
pda = ak.random_strings_lognormal(2, 0.25, 100, characters='printable')
self.assertIsInstance(pda, ak.Strings)
self.assertEqual(100, len(pda))
self.assertEqual(str, pda.dtype)
with self.assertRaises(TypeError) as cm:
ak.random_strings_lognormal('2', 0.25, 100)
self.assertEqual("The logmean must be a float or int",
cm.exception.args[0])
with self.assertRaises(TypeError) as cm:
ak.random_strings_lognormal(2, 25, 100)
self.assertEqual("The logstd must be a float", cm.exception.args[0])
with self.assertRaises(TypeError) as cm:
ak.random_strings_lognormal(2, 0.25, '100')
self.assertEqual("The size must be an integer", cm.exception.args[0])
with self.assertRaises(TypeError) as cm:
ak.random_strings_lognormal(2, 0.25, 100, 1000000)
self.assertEqual("characters must be a str", cm.exception.args[0])
def setUp(self):
ArkoudaTest.setUp(self)
base_words1 = ak.random_strings_uniform(0,
10,
UNIQUE,
characters='printable')
base_words2 = ak.random_strings_lognormal(2,
0.25,
UNIQUE,
characters='printable')
self.base_words = ak.concatenate((base_words1, base_words2))
self.np_base_words = np.hstack(
(base_words1.to_ndarray(), base_words2.to_ndarray()))
choices = ak.randint(0, self.base_words.size, N)
self.strings = self.base_words[choices]
self.test_strings = self.strings.to_ndarray()
self.cat = ak.Categorical(self.strings)
x, w = tuple(zip(*Counter(''.join(self.base_words)).items()))
self.delim = np.random.choice(x, p=(np.array(w) / sum(w)))
def setUp(self):
self.maxDiff = None
ArkoudaTest.setUp(self)
base_words1 = ak.random_strings_uniform(1, 10, UNIQUE, characters='printable')
base_words2 = ak.random_strings_lognormal(2, 0.25, UNIQUE, characters='printable')
gremlins = ak.array(['"', ' ', ''])
self.gremlins = gremlins
self.base_words = ak.concatenate((base_words1, base_words2))
self.np_base_words = np.hstack((base_words1.to_ndarray(), base_words2.to_ndarray()))
choices = ak.randint(0, self.base_words.size, N)
self.strings = self.base_words[choices]
self.test_strings = self.strings.to_ndarray()
self.cat = ak.Categorical(self.strings)
x, w = tuple(zip(*Counter(''.join(self.base_words.to_ndarray())).items()))
self.delim = np.random.choice(x, p=(np.array(w)/sum(w)))
self.akset = set(ak.unique(self.strings).to_ndarray())
self.gremlins_base_words = base_words = ak.concatenate((base_words1, base_words2, gremlins))
self.gremlins_strings = ak.concatenate((base_words[choices], gremlins))
self.gremlins_test_strings = self.gremlins_strings.to_ndarray()
self.gremlins_cat = ak.Categorical(self.gremlins_strings)
print("=================In Class will check===========================")
print("")
print(str(base_words1))
print("After base_word1 ")
print("")
print(str(self.strings))
print("After Print strings")
print(str(self.test_strings))
print("")
print("After Print teststrings")
print(str(self.strings[N//3]))
print("")
print("After Print strings[N//3]")
print(str(self.test_strings[N//3]))
print("")
print("After Print test_strings[N//3]")
if __name__ == '__main__':
import sys
if len(sys.argv) > 1:
ak.connect(server=sys.argv[1], port=sys.argv[2])
else:
ak.connect()
print("Running test from string_test.__main__")
# with open(__file__, 'r') as f:
# base_words = np.array(f.read().split())
# test_strings = np.random.choice(base_words, N, replace=True)
# strings = ak.array(test_strings)
base_words1 = ak.random_strings_uniform(1, 10, UNIQUE, characters='printable')
base_words2 = ak.random_strings_lognormal(2, 0.25, UNIQUE, characters='printable')
gremlins = ak.array(['"', ' ', ''])
base_words = ak.concatenate((base_words1, base_words2))
np_base_words = np.hstack((base_words1.to_ndarray(), base_words2.to_ndarray()))
assert(compare_strings(base_words.to_ndarray(), np_base_words))
choices = ak.randint(0, base_words.size, N)
strings = base_words[choices]
test_strings = strings.to_ndarray()
cat = ak.Categorical(strings)
print("strings =", strings)
print("categorical =", cat)
print("Generation and concatenate passed")
# int index
run_test_index(strings, test_strings, cat, range(-len(gremlins), 0))
print("int index passed")
