def test_invalid_patterns(self):
# Testing invalid sequences on patternfinder
sequences = None
# null input as pattern input
with self.assertRaises(ValueError):
# Sequential pattern finder
seq2pat = Seq2Pat(sequences)
sequences = [[1, 2, 3], 'string', [1, 3, 6, 7]]
# non-list string input in the middle index of pattern input
with self.assertRaises(ValueError):
# Sequential pattern finder
seq2pat = Seq2Pat(sequences)
# non-list integer input in the last index of pattern input
sequences = [[1, 2, 3], [1, 3, 6, 7], 1]
with self.assertRaises(ValueError):
# Sequential pattern finder
seq2pat = Seq2Pat(sequences)
# non-list object input in the first index of pattern input
patterns = [set(), [1, 2, 3], [1, 3, 6, 7]]
def test_simultaneaous_mining(self):
# List of sequences
sequences = [[11, 12, 13]]
# Sequential pattern finder
seq2pat = Seq2Pat(sequences)
seq2pat2 = Seq2Pat(sequences)
unconstrained_result = seq2pat.get_patterns(1)
unconstrained_result2 = seq2pat2.get_patterns(1)
self.assertListEqual(unconstrained_result, unconstrained_result2)
self.assertListEqual(
[[12, 13, 1], [11, 13, 1], [11, 12, 1], [11, 12, 13, 1]],
unconstrained_result)
def test_input_one_constraint(self):
# API and Cython object test. Replicates command line:
# ./MPP -file input.txt -thr 0.001 -att input_att1.txt -lg 30 -ug 900 -ls 900 - us 3600 -out -write BMS_patt.txt
# input on Main.cpp and verifies output with data captured from original implementation
# Similar to default but with constraints on a single attribute- input_att1.txt
# Seq2Pat
patterns_file = self.DATA_DIR + "input.txt"
sequences = read_data(patterns_file)
seq2pat = Seq2Pat(sequences)
# Load Attributes
attribute_file = self.DATA_DIR + "input_att1.txt"
attr1_data = read_data(attribute_file)
att1 = Attribute(attr1_data)
cts1 = seq2pat.add_constraint(30 <= att1.gap() <= 900)
cts2 = seq2pat.add_constraint(900 <= att1.span())
test_patterns = seq2pat.get_patterns(.001)
results_file = self.DATA_DIR + "one_constraint_results.txt"
control_patterns = read_data(results_file)
sorted_controls = sort_pattern(control_patterns)
self.assertListEqual(sorted_controls, test_patterns)
self.assertFalse(test_patterns == read_data(self.DATA_DIR +
"default_results.txt"))
def test_input_diff_constraint(self):
# API and Cython object test. Replicates command line:
# ./MPP -file input.txt -thr 0.001 -att input_att1.txt -lg 20 -ug 1000 -ls 800 - us 3700 -att input_att2.txt -la 20 -ua 80 -lm 30 -um 70 -out -write BMS_patt.txt
# input on Main.cpp and verifies output with data captured from original implementation
# Similar to default but all lower constraints lowered by 10 all upper constraints raised 10.
# Significantly different results to default.
# Seq2Pat
patterns_file = self.DATA_DIR + "input.txt"
sequences = read_data(patterns_file)
seq2pat = Seq2Pat(sequences)
# Load Attributes
attribute_file = self.DATA_DIR + "input_att1.txt"
attr1_data = read_data(attribute_file)
att1 = Attribute(attr1_data)
attribute_file = self.DATA_DIR + "input_att2.txt"
attr2_data = read_data(attribute_file)
att2 = Attribute(attr2_data)
cts1 = seq2pat.add_constraint(20 <= att1.gap() <= 1000)
cts2 = seq2pat.add_constraint(800 <= att1.span() <= 3700)
cts3 = seq2pat.add_constraint(20 <= att2.average() <= 80)
cts4 = seq2pat.add_constraint(30 <= att2.median() <= 70)
test_patterns = seq2pat.get_patterns(.001)
results_file = self.DATA_DIR + "diff_constraints_results.txt"
control_patterns = read_data(results_file)
sorted_control = sort_pattern(control_patterns)
self.assertListEqual(sorted_control, test_patterns)
def test_usage(self):
# Pattern data
patterns_file = self.DATA_DIR + "input.txt"
sequences = read_data(patterns_file)
# print("Patterns: ", sequences[:5])
# Attribute data
attribute_file = self.DATA_DIR + "input_att1.txt"
attribute_1 = read_data(attribute_file)
# print("Attribute_1: ", attribute_1[:5])
# Sequential pattern finder
seq2pat = Seq2Pat(sequences)
# Constraints on attribute 1
att1 = Attribute(attribute_1)
avg_constraint = seq2pat.add_constraint(5 <= att1.average())
gap_constraint = seq2pat.add_constraint(att1.gap() <= 10)
median_constraint = seq2pat.add_constraint(10 <= att1.median() <= 15)
span_constraint = seq2pat.add_constraint(att1.span() <= 20)
# Print constraint store
# seq2pat.__str__()
seq2pat.get_patterns(min_frequency=100)
def test_input_no_upper_constraint(self):
# API and Cython object test. Replicates command line:
# ./MPP -file input.txt -thr 0.01 -att input_att1.txt -lg 30 -ls 900 -att input_att2.txt -la 30 -lm 40 -out -write BMS_patt.txt
# input on Main.cpp and verifies output with data captured from original implementation
# Similar to default but no upper constraints imposed
# Seq2Pat
patterns_file = self.DATA_DIR + "input.txt"
sequences = read_data(patterns_file)
seq2pat = Seq2Pat(sequences)
# Load Attributes
attribute_file = self.DATA_DIR + "input_att1.txt"
attr1_data = read_data(attribute_file)
att1 = Attribute(attr1_data)
attribute_file = self.DATA_DIR + "input_att2.txt"
attr2_data = read_data(attribute_file)
att2 = Attribute(attr2_data)
cts1 = seq2pat.add_constraint(30 <= att1.gap())
cts2 = seq2pat.add_constraint(900 <= att1.span())
cts3 = seq2pat.add_constraint(30 <= att2.average())
cts4 = seq2pat.add_constraint(40 <= att2.median())
test_patterns = seq2pat.get_patterns(.01)
results_file = self.DATA_DIR + "no_upper_constraint_results.txt"
control_patterns = read_data(results_file)
sorted_control = sort_pattern(control_patterns)
self.assertListEqual(sorted_control, test_patterns)
def test_example(self):
# Seq2Pat over 3 sequences
seq2pat = Seq2Pat(sequences=[["A", "C", "B", "A", "D"],
["C", "B", "A"], ["C", "A", "C", "D"]])
# Patterns
patterns = seq2pat.get_patterns(min_frequency=2)
# print("Initial Patterns: ", patterns, "\n")
# Attribute - I: Price
price = Attribute(values=[[5, 5, 3, 8, 2], [1, 3, 3], [4, 5, 2, 1]])
# Attribute - II: Timestamp
timestamp = Attribute(
values=[[1, 1, 2, 3, 3], [3, 8, 9], [2, 5, 5, 7]])
# Add Constraint
avg_constraint = 3 <= price.average() <= 5
# avg_constraint = 4 <= price.average() <= 4
seq2pat.add_constraint(avg_constraint)
# Patterns
patterns = seq2pat.get_patterns(min_frequency=2)
# print("Average Constraint:", patterns, "\n")
# Remove Constraint
seq2pat.remove_constraint(avg_constraint)
patterns = seq2pat.get_patterns(min_frequency=2)
def test_min_frequence_zero_float(self):
# Seq2Pat over 3 sequences
seq2pat = Seq2Pat(sequences=[[1, 1, 2, 1, 4], [3, 2, 1], [3, 1, 3, 4]])
# Find sequences that occur at least twice
with self.assertRaises(ValueError):
patterns = seq2pat.get_patterns(min_frequency=0.0)
def test_min_frequence_negative(self):
# Seq2Pat over 3 sequences
seq2pat = Seq2Pat(sequences=[[1, 1, 2, 1, 4], [3, 2, 1], [3, 1, 3, 4]])
# Price attribute corresponding to each event
price = Attribute(values=[[5, 5, 3, 8, 2], [1, 3, 3], [4, 5, 2, 1]])
with self.assertRaises(ValueError):
patterns = seq2pat.get_patterns(min_frequency=-1)
def test_string_from_int(self):
# Seq2Pat
seq2pat = Seq2Pat(
sequences=[[1, 3, 2, 3], [4, 1, 5, 2, 10, 3],
[10, 10, 3, 1, 1, 2, 9, 3], [4, 1, 3, 2, 1, 3]])
# Find sequences
patterns = seq2pat.get_patterns(min_frequency=4)
# Same solution as string version
self.assertListEqual([[2, 3, 4], [1, 3, 4], [1, 2, 4], [1, 2, 3, 4]],
patterns)
def test_min_frequence_float_large(self):
# Seq2Pat over 3 sequences
seq2pat = Seq2Pat(sequences=[[1, 1, 2, 1, 4], [3, 2, 1], [3, 1, 3, 4]])
# Price attribute corresponding to each event
price = Attribute(values=[[5, 5, 3, 8, 2], [1, 3, 3], [4, 5, 2, 1]])
# Constraint to specify average price of sequences
seq2pat.add_constraint(-6 <= price.gap())
# Find sequences that occur at least twice
with self.assertRaises(ValueError):
patterns = seq2pat.get_patterns(min_frequency=2.5)
def test_quick_start_int(self):
# Seq2Pat over 3 sequences
seq2pat = Seq2Pat(sequences=[[1, 1, 2, 1, 4], [3, 2, 1], [3, 1, 3, 4]])
# Price attribute corresponding to each event
price = Attribute(values=[[5, 5, 3, 8, 2], [1, 3, 3], [4, 5, 2, 1]])
# Constraint to specify average price of sequences
seq2pat.add_constraint(-6 <= price.gap())
# seq2pat.add_constraint(3 <= price.average() <= 6)
# Find sequences that occur at least twice
patterns = seq2pat.get_patterns(min_frequency=2)
def test_invalid_freq(self):
# Test get_patterns invalid input value error
# List of sequences
sequences = [[1, 2, 3], [4, 5], [1, 3, 6, 7]]
# Sequential pattern finder
seq2pat = Seq2Pat(sequences)
with self.assertRaises(ValueError):
seq2pat.get_patterns(-1)
with self.assertRaises(ValueError):
seq2pat.get_patterns(0)
def test_span_inequality(self):
# List of sequences
sequences = [[11, 12, 13]]
# Sequential pattern finder
seq2pat = Seq2Pat(sequences)
unconstrained_result = seq2pat.get_patterns(1)
self.assertListEqual(
[[12, 13, 1], [11, 13, 1], [11, 12, 1], [11, 12, 13, 1]],
unconstrained_result)
# Attributes of sequences min span is 10 between any two events,
# max span is between event 11 and 13 with a value of 20
attributes = [[10, 20, 30]]
att1 = Attribute(attributes)
# Should be empty upper and lower bounds exceed span between any two events
span_constraint = seq2pat.add_constraint(11 <= att1.span() <= 19)
self.assertListEqual([], seq2pat.get_patterns(1))
seq2pat.remove_constraint(11 <= att1.span() <= 19)
# Should include any sequence with span between any two events with a value equal to or greater than 10
# and equal to or less than 19
span_constraint = seq2pat.add_constraint(10 <= att1.span() <= 19)
self.assertListEqual([[12, 13, 1], [11, 12, 1]],
seq2pat.get_patterns(1))
seq2pat.remove_constraint(10 <= att1.span() <= 11)
# Should include any sequence with span between any two events with a value equal to or greater than 11
# and equal to or less than 20
span_constraint = seq2pat.add_constraint(11 <= att1.span() <= 20)
self.assertListEqual([[11, 13, 1], [11, 12, 13, 1]],
seq2pat.get_patterns(1))
seq2pat.remove_constraint(11 <= att1.span() <= 20)
# Equivalent to unconstrained span to get pattern since values of att1 fall between bounds
span_constraint = seq2pat.add_constraint(10 <= att1.span() <= 20)
self.assertListEqual(
[[12, 13, 1], [11, 13, 1], [11, 12, 1], [11, 12, 13, 1]],
seq2pat.get_patterns(1))
def test_median_inequality(self):
# List of sequences
sequences = [[11, 12, 13]]
# Sequential pattern finder
seq2pat = Seq2Pat(sequences)
unconstrained_result = seq2pat.get_patterns(1)
self.assertListEqual(
[[12, 13, 1], [11, 13, 1], [11, 12, 1], [11, 12, 13, 1]],
unconstrained_result)
# Attributes of sequences min median is 15 for sequence [11, 12],
# max median is 25 for sequence [12, 13]
attributes = [[10, 20, 30]]
att1 = Attribute(attributes)
# Should be empty upper and lower bounds exceed median between any two events
gap_constraint = seq2pat.add_constraint(16 <= att1.median() <= 19)
self.assertListEqual([], seq2pat.get_patterns(1))
seq2pat.remove_constraint(16 <= att1.median() <= 19)
# Should include any sequence with median between any two events with a value equal to or greater than 15
# and equal to or less than 19
gap_constraint = seq2pat.add_constraint(15 <= att1.median() <= 19)
self.assertListEqual([[11, 12, 1]], seq2pat.get_patterns(1))
seq2pat.remove_constraint(15 <= att1.median() <= 19)
# Should include any sequence with median between any two events with a value equal to or greater than 16
# and equal to or less than 20
seq2pat.add_constraint(16 <= att1.median() <= 20)
self.assertListEqual([[11, 13, 1], [11, 12, 13, 1]],
seq2pat.get_patterns(1))
seq2pat.remove_constraint(16 <= att1.median() <= 20)
# Equivalent to unconstrained span to get pattern since values of att1 fall between bounds
seq2pat.add_constraint(15 <= att1.median() <= 25)
self.assertListEqual(
[[12, 13, 1], [11, 13, 1], [11, 12, 1], [11, 12, 13, 1]],
seq2pat.get_patterns(1))
def test_string(self):
# Seq2Pat
seq2pat = Seq2Pat(
sequences=[["A", "C", "B", "C"], ["D", "A", "E", "B", "W", "C"],
["W", "W", "C", "A", "A", "B", "S", "C"],
["D", "A", "C", "B", "A", "C"]])
# Find sequences
patterns = seq2pat.get_patterns(min_frequency=4)
# print(patterns)
self.assertEqual(4, len(patterns))
self.assertTrue(['B', 'C', 4] in patterns)
self.assertTrue(['A', 'C', 4] in patterns)
self.assertTrue(['A', 'B', 4] in patterns)
self.assertTrue(['A', 'B', 'C', 4] in patterns)
def test_from_mpp(self):
# Seq2Pat over 3 sequences
seq2pat = Seq2Pat(sequences=[["A", "A", "B", "A", "D"],
["C", "B", "A"], ["C", "A", "C", "D"]])
# Time attribute corresponding to each event
time = Attribute(values=[[1, 1, 2, 3, 3], [3, 8, 9], [2, 5, 5, 7]])
# Price attribute corresponding to each event
price = Attribute(values=[[5, 5, 3, 8, 2], [1, 3, 3], [4, 5, 2, 1]])
# Constraint to specify average price over the sequences
# seq2pat.add_constraint(3 <= price.average() <= 4)
# seq2pat.add_constraint(-1 <= price.span() <= -1)
# Find sequences
patterns = seq2pat.get_patterns(min_frequency=3)
def test_input_no_constraint(self):
# API and Cython object test. Replicates command line:
# ./MPP -file input.txt -thr 0.01 -out
# input on Main.cpp and verifies output with data captured from original implementation
# Unconstrained call. Significantly different and larger results.
# Seq2Pat
patterns_file = self.DATA_DIR + "input.txt"
sequences = read_data(patterns_file)
seq2pat = Seq2Pat(sequences)
test_patterns = seq2pat.get_patterns(.01)
results_file = self.DATA_DIR + "no_constraints_results.txt"
control_patterns = read_data(results_file)
sorted_results = sort_pattern(control_patterns)
self.assertListEqual(sorted_results, test_patterns)
self.assertFalse(test_patterns == read_data(self.DATA_DIR +
"default_results.txt"))
def test_usage_lb_ub(self):
# List of sequences
sequences = [[1, 2, 3], [4, 5], [1, 3, 6, 7]]
# Sequential pattern finder
seq2pat = Seq2Pat(sequences)
# Attributes of sequences
attributes = [[10, 20, 30], [40, 50], [10, 30, 60, 70]]
att1 = Attribute(attributes)
att2 = Attribute(attributes)
# Add constraints on the attributes
gap_constraint = 0 <= att1.gap() <= 10
seq2pat.add_constraint(gap_constraint)
avg_constraint = seq2pat.add_constraint(20 <= att1.average() <= 30)
median_constraint = seq2pat.add_constraint(-1 <= att1.median() <= 1000)
span_constraint = seq2pat.add_constraint(0 <= att1.span() <= 900)
span_constraint2 = seq2pat.add_constraint(-10 <= att2.span() <= 5)
# seq2pat.__str__()
self.assertEqual(gap_constraint.lower_bound, 0)
self.assertEqual(avg_constraint.lower_bound, 20)
self.assertEqual(median_constraint.lower_bound, -1)
self.assertEqual(span_constraint.lower_bound, 0)
self.assertEqual(span_constraint2.lower_bound, -10)
self.assertEqual(gap_constraint.upper_bound, 10)
self.assertEqual(avg_constraint.upper_bound, 30)
self.assertEqual(median_constraint.upper_bound, 1000)
self.assertEqual(span_constraint.upper_bound, 900)
self.assertEqual(span_constraint2.upper_bound, 5)
# Remove constraints
seq2pat.remove_constraint(gap_constraint)
seq2pat.remove_constraint(avg_constraint)
seq2pat.remove_constraint(median_constraint)
seq2pat.remove_constraint(span_constraint)
# seq2pat.__str__()
# Add again
seq2pat.add_constraint(gap_constraint)
seq2pat.add_constraint(span_constraint)
def test_min_frequency_as_1dot0_float(self):
# Seq2Pat over 3 sequences
seq2pat = Seq2Pat(sequences=[["A", "A", "B", "A", "D"],
["C", "B", "A"], ["C", "A", "C", "D"]])
# Create price attributes
price = Attribute(values=[[5, 5, 3, 8, 2], [1, 3, 3], [4, 5, 2, 1]])
# Create a time attribute
timestamp = Attribute(
values=[[1, 1, 2, 3, 3], [3, 8, 9], [2, 5, 5, 7]])
# Find sequences with min_frequency=1.0
patterns = seq2pat.get_patterns(min_frequency=1.0)
# print(patterns)
# Same solution as CMU commandline tool
self.assertListEqual([], patterns)
def test_attribute_mapping(self):
# Test to verify that attributes that will be checked for constraint satisfaction
# during mining are a one-to-one mapping between itself and items
sequences = [[1, 2, 3], [4, 5], [1, 3, 6, 7]]
# Sequential pattern finder
seq2pat = Seq2Pat(sequences)
# Number of values in row 1 in attribute is larger than the number of event in sequence one of sequences
attribute = [[1, 2, 3, 5], [4, 5], [1, 3, 6, 7]]
att1 = Attribute(attribute)
with self.assertRaises(ValueError):
seq2pat.add_constraint(0 <= att1.gap() <= 10)
# Number of values in row 2 in attribute is less than the number of event in sequence one of sequences
attribute = [[1, 2, 3, 5], [4], [1, 3, 6, 7]]
att1 = Attribute(attribute)
with self.assertRaises(ValueError):
seq2pat.add_constraint(0 <= att1.gap() <= 10)
def test_usage_example_span(self):
# Seq2Pat over 3 sequences
seq2pat = Seq2Pat(sequences=[["A", "A", "B", "A", "D"],
["C", "B", "A"], ["C", "A", "C", "D"]])
# Create price attributes
price = Attribute(values=[[5, 5, 3, 8, 2], [1, 3, 3], [4, 5, 2, 1]])
# Create a time attribute
timestamp = Attribute(
values=[[1, 1, 2, 3, 3], [3, 8, 9], [2, 5, 5, 7]])
# Constraint to specify the span of time in a pattern. Span is max(attributes) - min(attributes)
span_constraint = seq2pat.add_constraint(0 <= timestamp.span() <= 2)
# Find sequences that occur at least twice within span of time range
patterns = seq2pat.get_patterns(min_frequency=2)
# Same solution as CMU commandline tool
self.assertListEqual([['A', 'D', 2], ['B', 'A', 2]], sorted(patterns))
def test_usage_example_gap(self):
# Seq2Pat over 3 sequences
seq2pat = Seq2Pat(sequences=[["A", "A", "B", "A", "D"],
["C", "B", "A"], ["C", "A", "C", "D"]])
# Create price attributes
price = Attribute(values=[[5, 5, 3, 2, 8], [1, 3, 3], [4, 1, 2, 5]])
# Create a time attribute
timestamp = Attribute(
values=[[1, 1, 2, 3, 3], [3, 8, 9], [2, 5, 5, 7]])
# Constraint to specify the gap between two consecutive prices
gap_constraint = seq2pat.add_constraint(4 <= price.gap() <= 6)
# Find sequences that occur at least twice within gap between prices range
patterns = seq2pat.get_patterns(min_frequency=2)
# Same solution as CMU commandline tool
self.assertListEqual([['A', 'D', 2]], patterns)
def test_usage_example_average(self):
# Seq2Pat over 3 sequences
seq2pat = Seq2Pat(sequences=[["A", "A", "B", "A", "D"],
["C", "B", "A"], ["C", "A", "C", "D"]])
# Create price attributes
price = Attribute(values=[[5, 5, 3, 8, 2], [1, 3, 3], [4, 5, 2, 1]])
# Create a time attribute
timestamp = Attribute(
values=[[1, 1, 2, 3, 3], [3, 8, 9], [2, 5, 5, 7]])
# Constraint to specify the average price of sequences
avg_constraint = seq2pat.add_constraint(3 <= price.average() <= 4)
# Find sequences that occur at least twice within average price range
patterns = seq2pat.get_patterns(min_frequency=2)
# Same solution as CMU commandline tool
self.assertListEqual([['A', 'D', 2]], patterns)
def test_seq2patfinder_default(self):
# API and Cython object test.
# Replicates command line:
# > ./MPP.exe
# -file input.txt
# -thr 0.001
# -att input_att1.txt -lg 30 -ug 900 -ls 900 - us 3600
# -att input_att2.txt -la 30 -ua 70 -lm 40 -um 60
# -out -write BMS_patt.txt
# input on Main.cpp and verifies output with data captured from original implementation
# Seq2Pat
patterns_file = self.DATA_DIR + "input.txt"
sequences = read_data(patterns_file)
seq2pat = Seq2Pat(sequences)
# Load Attributes
attribute_file = self.DATA_DIR + "input_att1.txt"
attr1_data = read_data(attribute_file)
att1 = Attribute(attr1_data)
attribute_file = self.DATA_DIR + "input_att2.txt"
attr2_data = read_data(attribute_file)
att2 = Attribute(attr2_data)
cts1 = seq2pat.add_constraint(30 <= att1.gap() <= 900)
cts2 = seq2pat.add_constraint(900 <= att1.span())
cts3 = seq2pat.add_constraint(30 <= att2.average() <= 70)
cts4 = seq2pat.add_constraint(40 <= att2.median() <= 60)
test_pf = seq2pat._get_cython_imp(-1)
self.assertListEqual([30], test_pf.lgap)
self.assertListEqual([900], test_pf.ugap)
self.assertListEqual([30], test_pf.lavr)
self.assertListEqual([70], test_pf.uavr)
self.assertListEqual([900], test_pf.lspn)
self.assertListEqual([], test_pf.uspn)
self.assertListEqual([40], test_pf.lmed)
self.assertListEqual([0], test_pf.ugapi)
self.assertListEqual([0], test_pf.lgapi)
self.assertListEqual([], test_pf.uspni)
self.assertListEqual([0], test_pf.lspni)
self.assertListEqual([1], test_pf.uavri)
self.assertListEqual([1], test_pf.lavri)
self.assertListEqual([1], test_pf.umedi)
self.assertListEqual([1], test_pf.lmedi)
self.assertListEqual([2, 0], test_pf.num_minmax)
self.assertListEqual([0, 2], test_pf.num_avr)
self.assertListEqual([0, 2], test_pf.num_med)
self.assertListEqual([0], test_pf.tot_gap)
self.assertListEqual([0], test_pf.tot_spn)
self.assertListEqual([1], test_pf.tot_avr)
self.assertEqual(161, test_pf.M)
self.assertEqual(52619, test_pf.N)
self.assertEqual(3340, test_pf.L)
self.assertListEqual([284871, 100], test_pf.max_attrs)
self.assertListEqual([0, 1], test_pf.min_attrs)
test_patterns = seq2pat.get_patterns(.001)
# Consistency sanity check
dup_patterns = seq2pat.get_patterns(.001)
self.assertListEqual(test_patterns, dup_patterns)
results_file = self.DATA_DIR + "default_results.txt"
control_patterns = read_data(results_file)
sorted_control = sort_pattern(control_patterns)
self.assertListEqual(sorted_control, test_patterns)
# Remove constraint and test
cts5 = seq2pat.remove_constraint(40 <= att2.median() <= 60)
ct6 = seq2pat.remove_constraint(30 <= att2.average() <= 70)
test_pf = seq2pat._get_cython_imp(-1)
self.assertListEqual([], test_pf.umedi)
self.assertListEqual([], test_pf.lmedi)
self.assertListEqual([], test_pf.uavr)
self.assertListEqual([], test_pf.uavri)
self.assertListEqual([0], test_pf.num_med)
one_constraint_result = seq2pat.get_patterns(.001)
results_file = self.DATA_DIR + "one_constraint_results.txt"
control_patterns = read_data(results_file)
sorted_controls = sort_pattern(control_patterns)
self.assertListEqual(sorted_controls, one_constraint_result)
def test_setter(self):
# Testing cython object setters and getters
python_seq2pat = stp.PySeq2pat()
patterns_file = self.DATA_DIR + "input.txt"
sequences = read_data(patterns_file)
seq2pat = Seq2Pat(sequences)
python_seq2pat.lgap = [30]
python_seq2pat.ugap = [900]
python_seq2pat.lspn = [77]
python_seq2pat.uspn = [9, 80]
python_seq2pat.lavr = [9, 88]
python_seq2pat.uavr = [7]
python_seq2pat.lmed = [9, 9, 8]
python_seq2pat.umed = [99999]
self.assertListEqual(python_seq2pat.lgap, [30])
self.assertListEqual(python_seq2pat.ugap, [900])
self.assertListEqual(python_seq2pat.lspn, [77])
self.assertListEqual(python_seq2pat.uspn, [9, 80])
self.assertListEqual(python_seq2pat.lavr, [9, 88])
self.assertListEqual(python_seq2pat.uavr, [7])
self.assertListEqual(python_seq2pat.lmed, [9, 9, 8])
self.assertListEqual(python_seq2pat.umed, [99999])
python_seq2pat.lgapi = [0]
python_seq2pat.ugapi = [0]
python_seq2pat.lspni = [1]
python_seq2pat.uspni = [1, 0]
python_seq2pat.lavri = [0, 1]
python_seq2pat.uavri = [0]
python_seq2pat.lmedi = [0, 1, 2]
python_seq2pat.umedi = [2]
#
self.assertListEqual(python_seq2pat.lgapi, [0])
self.assertListEqual(python_seq2pat.ugapi, [0])
self.assertListEqual(python_seq2pat.lspni, [1])
self.assertListEqual(python_seq2pat.uspni, [1, 0])
self.assertListEqual(python_seq2pat.lavri, [0, 1])
self.assertListEqual(python_seq2pat.uavri, [0])
self.assertListEqual(python_seq2pat.lmedi, [0, 1, 2])
self.assertListEqual(python_seq2pat.umedi, [2])
python_seq2pat.num_minmax = [0, 0, 0]
python_seq2pat.num_avr = [1, 1, 1]
python_seq2pat.num_med = [0, 1, 2]
python_seq2pat.tot_gap = [0, 1, 0]
python_seq2pat.tot_spn = [2, 2, 2]
python_seq2pat.tot_avr = [0, 1, 1]
self.assertListEqual(python_seq2pat.num_minmax, [0, 0, 0])
self.assertListEqual(python_seq2pat.num_avr, [1, 1, 1])
self.assertListEqual(python_seq2pat.num_med, [0, 1, 2])
self.assertListEqual(python_seq2pat.tot_gap, [0, 1, 0])
self.assertListEqual(python_seq2pat.tot_spn, [2, 2, 2])
self.assertListEqual(python_seq2pat.tot_avr, [0, 1, 1])
python_seq2pat.num_att = 3
python_seq2pat.N = 200
python_seq2pat.M = 999
python_seq2pat.L = 89
python_seq2pat.theta = 89
self.assertEqual(python_seq2pat.num_att, 3)
self.assertEqual(python_seq2pat.N, 200)
self.assertEqual(python_seq2pat.M, 999)
self.assertEqual(python_seq2pat.L, 89)
self.assertEqual(python_seq2pat.theta, 89)
