######################################################################### """ seq1 = Sequences(str(get_shared_data( "well_log_filtered.seq"))) Plot(seq1, ViewPoint="Data") Plot(seq1) SelectStep(seq1, 1000) Plot(seq1) #Display(seq1, 1, 17, "Gaussian", ViewPoint="SegmentProfile", NbSegmentation=5) Plot(seq1, 1, 17, "Gaussian", ViewPoint="SegmentProfile") # seq20 = Segmentation(seq1, 1, 20, "Gaussian") # seq40 = Segmentation(seq1, 1, 40, "Gaussian") # seq20 = Segmentation(seq1, 1, 20, "Mean") # seq40 = Segmentation(seq1, 1, 40, "Mean") # seq16 = Segmentation(seq1, 1, 16, "Gaussian", NbSegment->"Fixed") vec1 = Vectors(seq1) Plot(vec1) SelectStep(vec1, 1000) Plot(vec1) if __name__ == "__main__": runTestClass(TestMerge()) runTestClass(TestRemoveRun()) test_compute_state_sequence()
self.sequence = Sequences(get_shared_data("wij1.seq")) def _test_estimate(self): seq = self.sequence # data is a hsm class Estimate(seq, "SEMI-MARKOV", "Ordinary") class Test_Estimate_time_events(): """test not yet implemented""" pass class Test_Estimate_tops(): """tests not yet implemented""" def __init__(self): self.data = TopsData() def test_estimate(self): Estimate(self.data, MinPosition=1, MaxPosition=10) if __name__ == "__main__": runTestClass(Test_Estimate_HIDDEN_VARIABLE_ORDER_MARKOV()) runTestClass(Test_Estimate_VARIABLE_ORDER_MARKOV_from_markovian()) runTestClass(Test_Estimate_VARIABLE_ORDER_MARKOV()) runTestClass(Test_Estimate_Histogram()) runTestClass(Test_Estimate_tops()) runTestClass(Test_Estimate_HIDDEN_SEMI_MARKOV()) runTestClass(Test_Estimate_SEMI_MARKOV())
def __init__(self): _Cluster.__init__(self) self.data = self.create_data() def create_data(self): data = Sequences(str(get_shared_data('sequences2.seq'))) return data def test_cluster_step(self): data = self.data mode = True cluster1 = data.cluster_step(1, 2, mode) cluster2 = Cluster(data, "Step", 1, 2) assert str(cluster1) == str(cluster2) def test_cluster_limit(self): data = self.data cluster1 = data.cluster_limit(1, [2 ], True) cluster2 = Cluster(data, "Limit", 1, [2]) assert str(cluster1) == str(cluster2) if __name__ == "__main__": runTestClass(TestVectors1()) runTestClass(TestVectorsn()) runTestClass(TestSequences1()) runTestClass(TestSequencesn()) runTestClass(TestConvolution()) runTestClass(TestCompound()) runTestClass(TestHistogram())
def __init__(self): _Cluster.__init__(self) self.data = self.create_data() def create_data(self): data = Sequences(str(get_shared_data('sequences2.seq'))) return data def test_cluster_step(self): data = self.data mode = True cluster1 = data.cluster_step(1, 2, mode) cluster2 = Cluster(data, "Step", 1, 2) assert str(cluster1) == str(cluster2) def test_cluster_limit(self): data = self.data cluster1 = data.cluster_limit(1, [2], True) cluster2 = Cluster(data, "Limit", 1, [2]) assert str(cluster1) == str(cluster2) if __name__ == "__main__": runTestClass(TestVectors1()) runTestClass(TestVectorsn()) runTestClass(TestSequences1()) runTestClass(TestSequencesn()) runTestClass(TestConvolution()) runTestClass(TestCompound()) runTestClass(TestHistogram())
c2 = Clustering(matrix10, "Hierarchy", Algorithm="Agglomerative") c3 = Clustering(matrix10, "Hierarchy", Algorithm="Divisive") c4 = Clustering(matrix10, "Hierarchy", Algorithm="Ordering") assert c1 assert c2 assert c3 assert c4 assert ToDistanceMatrix(c1) # first argument is the Algorithm # * 0 for agglomerative # * 1 for divisive # Second argument is the criterion # * 2 for averaging #those 3 tests works on my laptop (TC, April 2009) but not on buildbot #assert c2 == matrix10.hierarchical_clustering(0, 2, "test", "test") #assert c3 == matrix10.hierarchical_clustering(1, 1, "test", "test") #assert c4 == matrix10.hierarchical_clustering(2, 0, "test", "test") # 1 for initialisation and 1 for divisive assert str(c1) == \ str(matrix10.partitioning_prototype(3, [1, 3, 12], 1, 1)) assert str(c1_bis) == \ str(matrix10.partitioning_prototype(3, [1, 3, 12], 1, 2)) if __name__ == "__main__": runTestClass(Test())
assert True try: d = Multinomial() assert False except: assert True def test_simulation(self): """simulate a vector of realizations""" d = Uniform(0, 1) try: import numpy l = numpy.zeros(100000) for i in range(len(l)): l[i] = d.simulation() assert ((0 < sum(l)) & (sum(l) < len(l))) except: pass def test_getters(self): dist = Distribution(Histogram([1, 1, 1, 2, 2, 2, 3, 3, 3])) assert dist.get_mean == 2 assert 0.3333 < dist.get_max < 0.3334 assert dist.get_mean == 2 assert 0.6666 < dist.get_variance < 0.6667 if __name__ == "__main__": runTestClass(Test()) runTestClass(TestDistribution())
"""test VarianceAnalysis""" # todo: finalise and make method variance_analysis robust. vec10 = self.vec10 va = VarianceAnalysis(vec10, 1, 4, "O") assert vec10.variance_analysis(1, 4, 1, "whatever", variance_type['O']) == \ str(va) try: va = VarianceAnalysis(vec10, 1, 4, "DUMMY") assert False except: assert True def test_contingency_table(self): """test contingency table""" vec10 = self.vec10 ct = ContingencyTable(vec10, 1, 4) assert ct and str(ct) ct2 = vec10.contingency_table(1, 4, "what", OutputFormat.ASCII) assert ct == ct2 def test_rank_computation(self): vec10 = self.vec10 ComputeRankCorrelation(vec10, Type="Kendall", FileName="test") #ComputeRankCorrelation(vec10, Type="Spearman", FileName="test") if __name__ == "__main__": test = Test() runTestClass(test)
except: assert True def test_simulation(self): """simulate a vector of realizations""" d = Uniform(0, 1) try: import numpy l = numpy.zeros(100000) for i in range(len(l)): l[i] = d.simulation() assert((0 < sum(l)) & (sum(l) < len(l))) except: pass def test_getters(self): dist = Distribution(Histogram([1, 1, 1, 2, 2, 2, 3, 3, 3])) assert dist.get_mean == 2 assert 0.3333 < dist.get_max < 0.3334 assert dist.get_mean == 2 assert 0.6666 < dist.get_variance < 0.6667 if __name__ == "__main__": runTestClass(Test()) runTestClass(TestDistribution())
except TypeError: assert True class _TestRegressionKernel(): def __init__(self): self.data = RegressionKernel(4, 0, 10) def test_max_value(self): assert self.data.max_value == 10 def test_min_value(self): assert self.data.min_value == 0 def test_get_ident(self): assert self.data.ident == 4 def others_to_be_done(self): #there are other methods that need to be tested with an #appropriate examples: #get_point #get_regression_df #get_residual_df #get_nb_parameter #get_parameter pass if __name__ == "__main__": runTestClass(TestRegression())
except TypeError: assert True class _TestRegressionKernel: def __init__(self): self.data = RegressionKernel(4, 0, 10) def test_max_value(self): assert self.data.max_value == 10 def test_min_value(self): assert self.data.min_value == 0 def test_get_ident(self): assert self.data.ident == 4 def others_to_be_done(self): # there are other methods that need to be tested with an # appropriate examples: # get_point # get_regression_df # get_residual_df # get_nb_parameter # get_parameter pass if __name__ == "__main__": runTestClass(TestRegression())
_c1 = Compare(meri1, meri2, meri3, 'N', Filename='result.dat', \ Format='SpreadSheet') os.remove('result.dat') try: _c1 = Compare(meri1, meri2, meri3, 'N', Filename='result.dat', \ Format='badname') assert False except ValueError: assert True class TestVectors(): def __init__(self): pass def test_compare_vectors(self): vec10 = Vectors(get_shared_data("chene_sessile.vec")) vec15 = SelectVariable(vec10, [1, 3, 6], Mode="Reject") assert vec15 matrix10 = Compare(vec15, VectorDistance("N", "N", "N")) assert matrix10 assert str(vec15.compare(VectorDistance("N", "N", "N"), True)) == str(matrix10) if __name__ == "__main__": runTestClass(TestHisto()) runTestClass(TestVectors())
class Test_Compare_hsmc_with_sequences(_Compare): def __init__(self): _Compare.__init__(self) self.data = self.create_data() def create_data(self): hsmc0 = HiddenSemiMarkov(get_shared_data("belren1.hsc")) hsmc1 = HiddenSemiMarkov(get_shared_data("elstar1.hsc")) seq0 = Sequences(get_shared_data("belren1.seq")) seq1 = Sequences(get_shared_data("elstar1.seq")) data0 = Estimate(seq0, "HIDDEN_SEMI-MARKOV", hsmc0) data1 = Estimate(seq1, "HIDDEN_SEMI-MARKOV", hsmc1) return [seq0, seq1, data0, data1] def test_compare(self): data = self.data matrix20 = Compare(Thresholding(data[2], MinProbability=0.001), data[0], Thresholding(data[3], MinProbability=0.001), data[1], 10000) assert matrix20 if __name__ == "__main__": runTestClass(Test_Compare_Histograms()) runTestClass(Test_Compare_Sequences()) runTestClass(Test_Compare_Sequences_VectorDistance()) runTestClass(Test_Compare_Vectors_VectorDistance()) runTestClass(Test_Compare_hsmc_with_sequences())
class Test_Compare_hsmc_with_sequences(_Compare): def __init__(self): _Compare.__init__(self) self.data = self.create_data() def create_data(self): hsmc0 = HiddenSemiMarkov(get_shared_data( "belren1.hsc")) hsmc1 = HiddenSemiMarkov(get_shared_data("elstar1.hsc")) seq0 = Sequences(get_shared_data( "belren1.seq")) seq1 = Sequences(get_shared_data( "elstar1.seq")) data0 = Estimate(seq0, "HIDDEN_SEMI-MARKOV", hsmc0) data1 = Estimate(seq1, "HIDDEN_SEMI-MARKOV", hsmc1) return [seq0, seq1, data0, data1] def test_compare(self): data = self.data matrix20 = Compare(Thresholding(data[2], MinProbability=0.001), data[0], Thresholding(data[3], MinProbability=0.001), data[1], 10000) assert matrix20 if __name__ == "__main__": runTestClass(Test_Compare_Histograms()) runTestClass(Test_Compare_Sequences()) runTestClass(Test_Compare_Sequences_VectorDistance()) runTestClass(Test_Compare_Vectors_VectorDistance()) runTestClass(Test_Compare_hsmc_with_sequences())
os.remove('result.dat') try: _c1 = Compare(meri1, meri2, meri3, 'N', Filename='result.dat', \ Format='badname') assert False except ValueError: assert True class TestVectors(): def __init__(self): pass def test_compare_vectors(self): vec10 = Vectors(get_shared_data("chene_sessile.vec")) vec15 = SelectVariable(vec10, [1, 3, 6], Mode="Reject") assert vec15 matrix10 = Compare(vec15, VectorDistance("N", "N", "N")) assert matrix10 assert str(vec15.compare(VectorDistance("N", "N", "N"), True)) == str(matrix10) if __name__ == "__main__": runTestClass(TestHisto()) runTestClass(TestVectors())
def test_vector(self): v = self.int_vector_data() v1 = SelectVariable(v, 1, Mode="keep") v2 = SelectVariable(v, 2, Mode="Keep") v3 = SelectVariable(v, 3, Mode="Keep") merged = MergeVariable(v1, v2, v3) merged2 = v1.merge_variable([v2, v3], 1) for i in range(3): for j in range(3): assert merged[i][j] == v[i][j] assert str(merged) == str(merged2) if __name__ == "__main__": runTestClass(TestSelectHist()) runTestClass(TestFit()) runTestClass(TestShift()) runTestClass(TestExtractHistogram()) runTestClass(TestMerge()) runTestClass(TestMergeVariable()) runTestClass(TestValueSelect()) runTestClass(TestSelectVariable()) runTestClass(TestSelectIndividual()) runTestClass(TestExtract()) runTestClass(TestExtractData()) runTestClass(TestExtractDistribution())
def __init__(self): TestComputeCorrelation.__init__(self) self.correlation = self.test_pearson() def test_filter(self): data = self.correlation ComputeWhiteNoiseCorrelation(data, [1, 1, 1]) def test_order(self): data = self.correlation ComputeWhiteNoiseCorrelation(data, 1) def test_distribution(self): data = self.correlation ComputeWhiteNoiseCorrelation(data , Distribution("BINOMIAL", 0,4,0.5)) class TestComputePartialAutoCorrelation(Data): def __init__(self): Data.__init__(self) def test_compute_partial_auto_correlation(self): ComputePartialAutoCorrelation(self.sequence, 2, MaxLag=5) ComputePartialAutoCorrelation(self.sequence, MaxLag=5) if __name__ == "__main__": runTestClass(TestComputeCorrelation()) runTestClass(TestComputePartialAutoCorrelation()) runTestClass(TestComputeWhiteNoiseCorrelation())
# todo: finalise and make method variance_analysis robust. vec10 = self.vec10 va = VarianceAnalysis(vec10, 1, 4, "O") assert vec10.variance_analysis(1, 4, 1, "whatever", variance_type['O']) == \ str(va) try: va = VarianceAnalysis(vec10, 1, 4, "DUMMY") assert False except: assert True def test_contingency_table(self): """test contingency table""" vec10 = self.vec10 ct = ContingencyTable(vec10, 1, 4) assert ct and str(ct) ct2 = vec10.contingency_table(1, 4, "what", OutputFormat.ASCII) assert ct == ct2 def test_rank_computation(self): vec10 = self.vec10 ComputeRankCorrelation(vec10, Type="Kendall", FileName="test") #ComputeRankCorrelation(vec10, Type="Spearman", FileName="test") if __name__ == "__main__": test = Test() runTestClass(test)
""" seq1 = Sequences(str(get_shared_data("well_log_filtered.seq"))) Plot(seq1, ViewPoint="Data") Plot(seq1) SelectStep(seq1, 1000) Plot(seq1) #Display(seq1, 1, 17, "Gaussian", ViewPoint="SegmentProfile", NbSegmentation=5) Plot(seq1, 1, 17, "Gaussian", ViewPoint="SegmentProfile") # seq20 = Segmentation(seq1, 1, 20, "Gaussian") # seq40 = Segmentation(seq1, 1, 40, "Gaussian") # seq20 = Segmentation(seq1, 1, 20, "Mean") # seq40 = Segmentation(seq1, 1, 40, "Mean") # seq16 = Segmentation(seq1, 1, 16, "Gaussian", NbSegment->"Fixed") vec1 = Vectors(seq1) Plot(vec1) SelectStep(vec1, 1000) Plot(vec1) if __name__ == "__main__": runTestClass(TestMerge()) runTestClass(TestRemoveRun()) test_compute_state_sequence()
def __init__(self): TestComputeCorrelation.__init__(self) self.correlation = self.test_pearson() def test_filter(self): data = self.correlation ComputeWhiteNoiseCorrelation(data, [1, 1, 1]) def test_order(self): data = self.correlation ComputeWhiteNoiseCorrelation(data, 1) def test_distribution(self): data = self.correlation ComputeWhiteNoiseCorrelation(data, Distribution("BINOMIAL", 0, 4, 0.5)) class TestComputePartialAutoCorrelation(Data): def __init__(self): Data.__init__(self) def test_compute_partial_auto_correlation(self): ComputePartialAutoCorrelation(self.sequence, 2, MaxLag=5) ComputePartialAutoCorrelation(self.sequence, MaxLag=5) if __name__ == "__main__": runTestClass(TestComputeCorrelation()) runTestClass(TestComputePartialAutoCorrelation()) runTestClass(TestComputeWhiteNoiseCorrelation())
# assert str(a)==str(b) def test_extract(self): pass self.data.extract(1, 1, 1) def test_extract_data(self): self.data.extract_data() """ hsm.nb_output_process hsm.ascii_write hsm.divergence_computation hsm.simulation_histogram hsm.extract_histogram hsm.simulation_markovian_sequences hsm.file_ascii_write hsm.get_forward hsm.simulation_nb_sequences hsm.get_plotable hsm.get_semi_markov_data hsm.state_sequence_computation hsm.get_state_subtype hsm.nb_iterator """ if __name__ == "__main__": runTestClass(Test())
def _test_estimate(self): seq = self.sequence # data is a hsm class Estimate(seq, "SEMI-MARKOV", "Ordinary") class Test_Estimate_time_events(): """test not yet implemented""" pass class Test_Estimate_tops(): """tests not yet implemented""" def __init__(self): self.data = TopsData() def test_estimate(self): Estimate(self.data, MinPosition=1, MaxPosition=10) if __name__ == "__main__": runTestClass(Test_Estimate_HIDDEN_VARIABLE_ORDER_MARKOV()) runTestClass(Test_Estimate_VARIABLE_ORDER_MARKOV_from_markovian()) runTestClass(Test_Estimate_VARIABLE_ORDER_MARKOV()) runTestClass(Test_Estimate_Histogram()) runTestClass(Test_Estimate_tops()) runTestClass(Test_Estimate_HIDDEN_SEMI_MARKOV()) runTestClass(Test_Estimate_SEMI_MARKOV())