def test_place_sums(): """ Test procedure for function place_sums """ print('Testing function place_sums') table = [['I1','I2','I3'], [0.8, 0.2], [0.6, 0.9], [0.4, 0.3]] goal = [['I1','I2','I3','Sum'], [0.8, 0.2, 1.0], [0.6, 0.9, 1.5], [0.4, 0.3, 0.7]] funcs.place_sums(table) introcs.assert_equals(goal[0],table[0]) for pos in range(1,len(table)): introcs.assert_float_lists_equal(goal[pos],table[pos]) table = [['I1','I2'], [0.2, -0.6, 0.1], [0.9, 0.8, -1.0]] goal = [['I1','I2','Sum'], [0.2, -0.6, 0.1, -0.3], [0.9, 0.8, -1.0, 0.7]] funcs.place_sums(table) introcs.assert_equals(goal[0],table[0]) for pos in range(1,len(table)): introcs.assert_float_lists_equal(goal[pos],table[pos]) table = [['I1'], [0.4, 0.8, 0.5, 0.4]] goal = [['I1','Sum'], [0.4, 0.8, 0.5, 0.4, 2.1]] funcs.place_sums(table) introcs.assert_equals(goal[0],table[0]) for pos in range(1,len(table)): introcs.assert_float_lists_equal(goal[pos],table[pos]) table = [['I1','I2','I3','I4'], [0.3], [0.5], [0.8], [0.4]] goal = [['I1','I2','I3','I4','Sum'], [0.3, 0.3], [0.5, 0.5], [0.8, 0.8], [0.4, 0.4]] funcs.place_sums(table) introcs.assert_equals(goal[0],table[0]) for pos in range(1,len(table)): introcs.assert_float_lists_equal(goal[pos],table[pos])
def test_row_sums(): """ Test procedure for function row_sums """ print('Testing function row_sums') result = funcs.row_sums([[0.8, 0.2], [0.6, 0.9], [0.4, 0.3]]) introcs.assert_float_lists_equal([1.0, 1.5, 0.7],result) result = funcs.row_sums([[0.2, -0.6, 0.1], [0.9, 0.8, -1.0]]) introcs.assert_float_lists_equal([-0.3, 0.7],result) result = funcs.row_sums([[0.4, 0.8, 0.5, 0.4]]) introcs.assert_float_lists_equal([2.1],result) result = funcs.row_sums([[0.3], [0.5], [0.8], [0.4]]) introcs.assert_float_lists_equal([0.3, 0.5, 0.8, 0.4],result)
def test_place_sums(): """ Test procedure for function place_sums(). Note the use of assert_float_lists_equal for testing (nested) lists of floats. """ print('Testing place_sums()') table = [['P1', 'P3', 'P5', 'P7', 'P9'], [0.7, 0.0, -0.7, 1.0, -0.9]] answr = [['P1', 'P3', 'P5', 'P7', 'P9', 'Sum'], [0.7, 0.0, -0.7, 1.0, -0.9, 0.1]] result = funcs.place_sums(table) introcs.assert_equals(None, result) # Need to check string part and float part separately introcs.assert_equals(answr[0], table[0]) introcs.assert_float_lists_equal(answr[1:], table[1:]) table = [['P1'], [0.7], [0.1], [0.4], [-0.2], [0.6]] answr = [['P1', 'Sum'], [0.7, 0.7], [0.1, 0.1], [0.4, 0.4], [-0.2, -0.2], [0.6, 0.6]] result = funcs.place_sums(table) introcs.assert_equals(None, result) # Need to check string part and float part separately introcs.assert_equals(answr[0], table[0]) introcs.assert_float_lists_equal(answr[1:], table[1:]) table = [['P1', 'P3', 'P5'], [0.7, 0.0, -0.7], [0.1, 0.4, -0.6]] answr = [['P1', 'P3', 'P5', 'Sum'], [0.7, 0.0, -0.7, 0.0], [0.1, 0.4, -0.6, -0.1]] result = funcs.place_sums(table) introcs.assert_equals(None, result) # Need to check string part and float part separately introcs.assert_equals(answr[0], table[0]) introcs.assert_float_lists_equal(answr[1:], table[1:]) table = [['P1', 'P3', 'P5', 'P7', 'P9'], [0.7, 0.0, -0.7, 1.0, -0.9], [0.1, 0.4, -0.6, 0.9, 0.2], [0.4, -0.1, -0.2, 0.1, -0.6], [-0.2, 0.2, 0.2, -0.3, -0.2], [0.6, -0.1, -0.0, 0.8, 0.9]] answr = [['P1', 'P3', 'P5', 'P7', 'P9', 'Sum'], [0.7, 0.0, -0.7, 1.0, -0.9, 0.1], [0.1, 0.4, -0.6, 0.9, 0.2, 1.0], [0.4, -0.1, -0.2, 0.1, -0.6, -0.4], [-0.2, 0.2, 0.2, -0.3, -0.2, -0.3], [0.6, -0.1, -0.0, 0.8, 0.9, 2.2]] result = funcs.place_sums(table) introcs.assert_equals(None, result) # Need to check string part and float part separately introcs.assert_equals(answr[0], table[0]) introcs.assert_float_lists_equal(answr[1:], table[1:])
def test_dataset(): """ Tests the Dataset class. """ print(' Testing class Dataset') # TEST CASE 1 # Create and test an empty dataset dset1 = a6dataset.Dataset(3) introcs.assert_equals(3, dset1.getDimension()) introcs.assert_equals(0, dset1.getSize()) # We use this assert function to compare lists introcs.assert_float_lists_equal([], dset1.getContents()) print(' Default initialization looks okay') # TEST CASE 2 # Create and test a non-empty dataset items = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] dset2 = a6dataset.Dataset(3, items) introcs.assert_equals(3, dset2.getDimension()) introcs.assert_equals(4, dset2.getSize()) # Check that contents is initialized correctly # Make sure items is COPIED assert_point_sets_equal(items, dset2.getContents()) introcs.assert_false(dset2.getContents() is items) introcs.assert_false(dset2.getContents()[0] is items[0]) print(' User-provided initialization looks okay') # Check that getPoint() is correct AND that it copies introcs.assert_float_lists_equal([0.0, 1.0, 0.0], dset2.getPoint(2)) introcs.assert_false(dset2.getContents()[2] is dset2.getPoint(2)) print(' Method Dataset.getPoint looks okay') # Add something to the dataset (and check it was added) dset1.addPoint([0.0, 0.5, 4.2]) assert_point_sets_equal([[0.0, 0.5, 4.2]], dset1.getContents()) introcs.assert_float_lists_equal([0.0, 0.5, 4.2], dset1.getPoint(0)) # Check the point is COPIED introcs.assert_false(dset1.getPoint(0) is dset1.getContents()[0]) extra = [0.0, 0.5, 4.2] dset2.addPoint(extra) items.append(extra) assert_point_sets_equal(items, dset2.getContents()) # Check the point was COPIED introcs.assert_false(id(extra) in map(id, dset2.getContents())) print(' Method Dataset.addPoint looks okay') print(' class Dataset appears correct') print()
def test_cluster_a(): """ Tests Part A of the Cluster class assignment. """ print(' Testing Part A of class Cluster') # TEST CASE 1 # Create and test a cluster (always empty) dset = a6dataset.Dataset(3) point = [0.0, 1.0, 0.0] cluster1 = a6cluster.Cluster(dset, point) # Compare centroid and contents introcs.assert_float_lists_equal(point, cluster1.getCentroid()) introcs.assert_equals([], cluster1.getIndices()) # Make sure centroid COPIED introcs.assert_not_equals(id(point), id(cluster1.getCentroid())) print(' Basic cluster methods look okay') # Add something to cluster (and check it was added) extra = [[0.0, 0.5, 4.2], [0.0, 1.0, 0.0]] dset.addPoint(extra[0]) dset.addPoint(extra[1]) cluster1.addIndex(1) introcs.assert_equals([1], cluster1.getIndices()) cluster1.addIndex(0) introcs.assert_equals([1, 0], cluster1.getIndices()) # Make sure we can handle duplicates! cluster1.addIndex(1) introcs.assert_equals([1, 0], cluster1.getIndices()) print(' Method Cluster.addIndex look okay') # And clear it contents = cluster1.getContents() introcs.assert_equals(2, len(contents)) introcs.assert_float_lists_equal(extra[1], contents[0]) introcs.assert_float_lists_equal(extra[0], contents[1]) print(' Method Cluster.getContents look okay') # And clear it cluster1.clear() introcs.assert_equals([], cluster1.getIndices()) print(' Method Cluster.clear look okay') print(' Part A of class Cluster appears correct') print()
def test_crossout(): """ Test procedure for function crossout(). Note the use of assert_float_lists_equal for testing (nested) lists of floats. """ print('Testing crossout()') table = [[0.1, 0.3, 0.5], [0.6, 0.2, 0.7], [1.5, 2.3, 0.4]] result = funcs.crossout(table, 1, 2) introcs.assert_equals(None, result) introcs.assert_float_lists_equal([[0.1, 0.3], [1.5, 2.3]], table) table = [[0.1, 0.3, 0.5], [0.6, 0.2, 0.7], [1.5, 2.3, 0.4]] result = funcs.crossout(table, 0, 0) introcs.assert_equals(None, result) introcs.assert_float_lists_equal([[0.2, 0.7], [2.3, 0.4]], table) table = [[0.1, 0.3, 0.5], [0.6, 0.2, 0.7], [1.5, 2.3, 0.4]] result = funcs.crossout(table, 2, 1) introcs.assert_equals(None, result) introcs.assert_float_lists_equal([[0.1, 0.5], [0.6, 0.7]], table) table = [[0.1, 0.3, 0.5], [0.6, 0.2, 0.7], [1.5, 2.3, 0.4], [0.1, 0.2, 0.3]] result = funcs.crossout(table, 1, 2) introcs.assert_equals(None, result) introcs.assert_float_lists_equal([[0.1, 0.3], [1.5, 2.3], [0.1, 0.2]], table) table = [[0.1, 0.3, 0.5, 1.0], [0.6, 0.2, 0.7, 2.0], [1.5, 2.3, 0.4, 3.0]] result = funcs.crossout(table, 1, 2) introcs.assert_equals(None, result) introcs.assert_float_lists_equal([[0.1, 0.3, 1.0], [1.5, 2.3, 3.0]], table) table = [[1, 2], [3, 4]] result = funcs.crossout(table, 1, 0) introcs.assert_equals(None, result) introcs.assert_float_lists_equal([[2]], table) table = [[1, 2], [3, 4]] result = funcs.crossout(table, 0, 1) introcs.assert_equals(None, result) introcs.assert_float_lists_equal([[3]], table) table = [[5]] result = funcs.crossout(table, 0, 0) introcs.assert_equals(None, result) introcs.assert_equals([], table)
def test_files_to_dictionary(): """ Test loading function files_to_dictionary """ files = ['colorblind/normal.dat','colorblind/tritanomaly.dat'] maps = a2.files_to_dictionary(files) introcs.assert_equals(2,len(maps)) introcs.assert_true('Normal' in maps) introcs.assert_true('Tritanomaly' in maps) introcs.assert_float_lists_equal([1,0,0],maps['Normal'][0]) introcs.assert_float_lists_equal([0,1,0],maps['Normal'][1]) introcs.assert_float_lists_equal([0,0,1],maps['Normal'][2]) introcs.assert_float_lists_equal([0.967, 0.033, 0],maps['Tritanomaly'][0]) introcs.assert_float_lists_equal([0, 0.733, 0.267],maps['Tritanomaly'][1]) introcs.assert_float_lists_equal([0, 0.183, 0.817],maps['Tritanomaly'][2])
def test_file_to_data(): """ Test file function file_to_data """ file = 'colorblind/normal.dat' data = a2.file_to_data(file) introcs.assert_equals('Normal',data[0]) introcs.assert_float_lists_equal([1,0,0],data[1]) introcs.assert_float_lists_equal([0,1,0],data[2]) introcs.assert_float_lists_equal([0,0,1],data[3]) file = 'colorblind/tritanomaly.dat' data = a2.file_to_data(file) introcs.assert_equals('Tritanomaly',data[0]) introcs.assert_float_lists_equal([0.967, 0.033, 0],data[1]) introcs.assert_float_lists_equal([0, 0.733, 0.267],data[2]) introcs.assert_float_lists_equal([0, 0.183, 0.817],data[3])
def test_algorithm_d(): """ Tests Part D of the Algorithm class. """ print(' Testing Part D of class Algorithm') items = [[0.5, 0.5, 0.5], [0.5, 0.6, 0.6], [0.6, 0.5, 0.6], [0.5, 0.6, 0.5], [0.5, 0.4, 0.5], [0.5, 0.4, 0.4]] dset = a6dataset.Dataset(3, items) # Try the same test case straight from the top using perform_k_means km1 = a6algorithm.Algorithm(dset, 2, [1, 3]) km1.run(10) # Check first cluster cluster1 = km1.getClusters()[0] introcs.assert_float_lists_equal([8. / 15, 17. / 30, 17. / 30], cluster1.getCentroid()) introcs.assert_equals(set([1, 2, 3]), set(cluster1.getIndices())) # Check second cluster cluster2 = km1.getClusters()[1] introcs.assert_float_lists_equal([0.5, 13. / 30, 14. / 30], cluster2.getCentroid()) introcs.assert_equals(set([0, 4, 5]), set(cluster2.getIndices())) print(' Method run looks okay') # Test on a real world data set file = os.path.join(os.path.split(__file__)[0], TEST_FILE) data = a6dataset.Dataset(4, tools.data_for_file(file)) km2 = a6algorithm.Algorithm(data, 3, [23, 54, 36]) km2.run(20) # The actual results cluster0 = km2.getClusters()[0] cluster1 = km2.getClusters()[1] cluster2 = km2.getClusters()[2] # The "correct" answers contents0 = [[0.88, 0.84, 0.8, 0.3], [0.02, 0.67, 0.75, 0.61], [0.81, 0.69, 0.65, 0.65], [0.62, 0.75, 0.65, 0.43], [0.35, 0.63, 0.65, 0.12], [0.61, 0.85, 0.81, 0.44], [0.95, 0.94, 0.98, 0.69], [0.04, 0.69, 0.38, 0.39], [0.28, 0.91, 0.63, 0.08], [0.38, 0.94, 0.53, 0.07], [0.08, 0.62, 0.32, 0.27], [0.69, 0.82, 0.75, 0.65], [0.84, 0.89, 0.91, 0.38], [0.22, 0.88, 0.39, 0.33], [0.71, 0.78, 0.64, 0.57], [0.15, 0.87, 0.62, 0.22], [0.65, 0.81, 0.69, 0.55], [0.27, 0.63, 0.69, 0.39], [0.35, 0.7, 0.41, 0.15], [0.91, 0.98, 0.61, 0.58], [0.9, 0.63, 0.83, 0.6], [0.95, 0.83, 0.64, 0.5], [0.76, 0.86, 0.74, 0.61], [0.27, 0.65, 0.52, 0.28], [0.86, 0.91, 0.88, 0.62], [0.1, 0.79, 0.5, 0.12], [0.99, 0.68, 0.8, 0.42], [0.09, 0.85, 0.55, 0.21], [0.79, 0.94, 0.83, 0.48], [0.73, 0.92, 0.74, 0.39], [0.89, 0.72, 0.78, 0.38], [0.39, 0.9, 0.52, 0.26], [0.46, 0.35, 0.96, 0.05], [0.21, 0.62, 0.33, 0.09], [0.58, 0.37, 0.9, 0.08], [0.54, 0.92, 0.36, 0.35], [0.67, 0.32, 0.66, 0.2], [0.36, 0.64, 0.57, 0.26], [0.9, 0.7, 0.74, 0.63], [0.4, 0.69, 0.74, 0.7]] contents1 = [[0.32, 0.87, 0.14, 0.68], [0.73, 0.31, 0.15, 0.08], [0.87, 0.99, 0.2, 0.8], [0.77, 0.45, 0.31, 0.31], [0.96, 0.09, 0.49, 0.3], [0.86, 0.03, 0.3, 0.39], [0.86, 0.86, 0.32, 0.88], [0.8, 0.4, 0.23, 0.33], [0.81, 0.66, 0.26, 0.82], [0.95, 0.62, 0.28, 0.01], [0.35, 0.71, 0.01, 0.32], [0.73, 0.65, 0.23, 0.02], [0.84, 0.88, 0.04, 0.86], [0.8, 0.62, 0.09, 0.65], [0.72, 0.55, 0.1, 0.17], [0.61, 0.42, 0.24, 0.33], [0.72, 0.88, 0.02, 0.95], [0.88, 0.96, 0.09, 0.88], [0.9, 0.05, 0.34, 0.41], [0.9, 0.41, 0.27, 0.36]] contents2 = [[0.4, 0.21, 0.78, 0.68], [0.54, 0.06, 0.81, 0.98], [0.2, 0.54, 0.73, 0.85], [0.14, 0.31, 0.86, 0.74], [0.39, 0.14, 0.99, 0.24], [0.23, 0.32, 0.7, 0.75], [0.65, 0.05, 0.39, 0.49], [0.04, 0.52, 0.99, 0.75], [0.14, 0.55, 0.67, 0.63], [0.5, 0.2, 0.69, 0.95], [0.79, 0.09, 0.41, 0.69], [0.4, 0.3, 0.78, 0.74], [0.65, 0.24, 0.63, 0.27], [0.35, 0.3, 0.94, 0.92], [0.39, 0.38, 0.85, 0.32], [0.38, 0.07, 0.82, 0.01], [0.66, 0.09, 0.69, 0.46], [0.26, 0.39, 0.95, 0.63], [0.54, 0.06, 0.74, 0.86], [0.2, 0.48, 0.98, 0.84], [0.62, 0.24, 0.77, 0.17], [0.27, 0.38, 0.76, 0.63], [0.7, 0.04, 0.7, 0.82], [0.41, 0.11, 0.61, 0.78], [0.22, 0.44, 0.67, 0.99], [0.51, 0.05, 0.95, 0.66], [0.44, 0.1, 0.61, 0.98], [0.31, 0.16, 0.95, 0.9], [0.31, 0.5, 0.87, 0.85], [0.5, 0.09, 0.84, 0.78], [0.62, 0.01, 0.88, 0.1], [0.44, 0.28, 0.88, 0.99], [0.57, 0.23, 0.6, 0.85], [0.72, 0.14, 0.63, 0.37], [0.39, 0.08, 0.77, 0.96], [0.09, 0.47, 0.63, 0.8], [0.63, 0.05, 0.52, 0.63], [0.62, 0.27, 0.67, 0.77], [0.35, 0.04, 0.85, 0.86], [0.36, 0.34, 0.75, 0.37]] centroid0 = [0.54125, 0.7545, 0.66125, 0.3775] centroid1 = [0.76900, 0.5705, 0.20550, 0.4775] centroid2 = [0.42325, 0.2330, 0.75775, 0.6765] introcs.assert_float_lists_equal(centroid0, cluster0.getCentroid()) introcs.assert_float_lists_equal(centroid1, cluster1.getCentroid()) introcs.assert_float_lists_equal(centroid2, cluster2.getCentroid()) assert_point_sets_equal(contents0, cluster0.getContents()) assert_point_sets_equal(contents1, cluster1.getContents()) assert_point_sets_equal(contents2, cluster2.getContents()) print(' File analysis test looks okay') print(' Part D of class ClusterGroup appears correct') print()
def test_algorithm_c(): """ Tests Part C of the Algorithm class. """ print(' Testing Part C of class Algorithm') items = [[0., 0.], [10., 1.], [10., 10.], [0., 9.]] dset = a6dataset.Dataset(2, items) km1 = a6algorithm.Algorithm(dset, 2, [0, 2]) km1._partition() # Test update() stable = km1._update() introcs.assert_float_lists_equal([0, 4.5], km1.getClusters()[0].getCentroid()) introcs.assert_float_lists_equal([10.0, 5.5], km1.getClusters()[1].getCentroid()) introcs.assert_false(stable) # updating again should not change anything, but should return stable stable = km1._update() introcs.assert_float_lists_equal([0, 4.5], km1.getClusters()[0].getCentroid()) introcs.assert_float_lists_equal([10.0, 5.5], km1.getClusters()[1].getCentroid()) introcs.assert_true(stable) print(' Method Algorithm._update() looks okay') # Now test the k-means process itself. # FOR ALL TEST CASES # Create and initialize a non-empty dataset items = [[0.5, 0.5, 0.5], [0.5, 0.6, 0.6], [0.6, 0.5, 0.6], [0.5, 0.6, 0.5], [0.5, 0.4, 0.5], [0.5, 0.4, 0.4]] dset = a6dataset.Dataset(3, items) # Create a clustering, providing non-random seed indices so the test is deterministic km2 = a6algorithm.Algorithm(dset, 2, [1, 3]) # PRE-TEST: Check first cluster (should be okay if passed part D) cluster1 = km2.getClusters()[0] introcs.assert_float_lists_equal([0.5, 0.6, 0.6], cluster1.getCentroid()) introcs.assert_equals(set([]), set(cluster1.getIndices())) # PRE-TEST: Check second cluster (should be okay if passed part D) cluster2 = km2.getClusters()[1] introcs.assert_float_lists_equal([0.5, 0.6, 0.5], cluster2.getCentroid()) introcs.assert_equals(set([]), set(cluster2.getIndices())) # Make a fake cluster to test update_centroid() method clustertest = a6cluster.Cluster(dset, [0.5, 0.6, 0.6]) for ind in [1, 2]: clustertest.addIndex(ind) # TEST CASE 1 (update) stable = clustertest.update() introcs.assert_float_lists_equal([0.55, 0.55, 0.6], clustertest.getCentroid()) introcs.assert_false(stable) # Not yet stable # TEST CASE 2 (update) stable = clustertest.update() introcs.assert_float_lists_equal([0.55, 0.55, 0.6], clustertest.getCentroid()) introcs.assert_true(stable) # Now it is stable # TEST CASE 3 (step) km2.step() # Check first cluster (WHICH HAS CHANGED!) cluster1 = km2.getClusters()[0] introcs.assert_float_lists_equal([0.55, 0.55, 0.6], cluster1.getCentroid()) introcs.assert_equals(set([1, 2]), set(cluster1.getIndices())) # Check second cluster (WHICH HAS CHANGED!) cluster2 = km2.getClusters()[1] introcs.assert_float_lists_equal([0.5, 0.475, 0.475], cluster2.getCentroid()) introcs.assert_equals(set([0, 3, 4, 5]), set(cluster2.getIndices())) # TEST CASE 3 (step) km2.step() # Check first cluster (WHICH HAS CHANGED!) cluster1 = km2.getClusters()[0] introcs.assert_float_lists_equal([8. / 15, 17. / 30, 17. / 30], cluster1.getCentroid()) introcs.assert_equals(set([1, 2, 3]), set(cluster1.getIndices())) # Check second cluster (WHICH HAS CHANGED!) cluster2 = km2.getClusters()[1] introcs.assert_float_lists_equal([0.5, 13. / 30, 14. / 30], cluster2.getCentroid()) introcs.assert_equals(set([0, 4, 5]), set(cluster2.getIndices())) # Try it on a file file = os.path.join(os.path.split(__file__)[0], TEST_FILE) data = a6dataset.Dataset(4, tools.data_for_file(file)) km3 = a6algorithm.Algorithm(data, 3, [23, 54, 36]) km3.step() # The actual results cluster0 = km3.getClusters()[0] cluster1 = km3.getClusters()[1] cluster2 = km3.getClusters()[2] # The "correct" answers contents0 = [[0.88, 0.84, 0.8, 0.3], [0.02, 0.67, 0.75, 0.61], [0.2, 0.54, 0.73, 0.85], [0.62, 0.75, 0.65, 0.43], [0.35, 0.63, 0.65, 0.12], [0.61, 0.85, 0.81, 0.44], [0.95, 0.94, 0.98, 0.69], [0.04, 0.69, 0.38, 0.39], [0.04, 0.52, 0.99, 0.75], [0.28, 0.91, 0.63, 0.08], [0.14, 0.55, 0.67, 0.63], [0.38, 0.94, 0.53, 0.07], [0.08, 0.62, 0.32, 0.27], [0.69, 0.82, 0.75, 0.65], [0.84, 0.89, 0.91, 0.38], [0.22, 0.88, 0.39, 0.33], [0.39, 0.38, 0.85, 0.32], [0.26, 0.39, 0.95, 0.63], [0.15, 0.87, 0.62, 0.22], [0.65, 0.81, 0.69, 0.55], [0.27, 0.63, 0.69, 0.39], [0.35, 0.7, 0.41, 0.15], [0.2, 0.48, 0.98, 0.84], [0.76, 0.86, 0.74, 0.61], [0.27, 0.65, 0.52, 0.28], [0.86, 0.91, 0.88, 0.62], [0.1, 0.79, 0.5, 0.12], [0.09, 0.85, 0.55, 0.21], [0.79, 0.94, 0.83, 0.48], [0.73, 0.92, 0.74, 0.39], [0.31, 0.5, 0.87, 0.85], [0.39, 0.9, 0.52, 0.26], [0.46, 0.35, 0.96, 0.05], [0.21, 0.62, 0.33, 0.09], [0.58, 0.37, 0.9, 0.08], [0.54, 0.92, 0.36, 0.35], [0.36, 0.64, 0.57, 0.26], [0.09, 0.47, 0.63, 0.8], [0.4, 0.69, 0.74, 0.7]] contents1 = [[0.32, 0.87, 0.14, 0.68], [0.87, 0.99, 0.2, 0.8], [0.86, 0.86, 0.32, 0.88], [0.81, 0.66, 0.26, 0.82], [0.91, 0.98, 0.61, 0.58], [0.84, 0.88, 0.04, 0.86], [0.8, 0.62, 0.09, 0.65], [0.72, 0.88, 0.02, 0.95], [0.88, 0.96, 0.09, 0.88]] contents2 = [[0.4, 0.21, 0.78, 0.68], [0.54, 0.06, 0.81, 0.98], [0.73, 0.31, 0.15, 0.08], [0.81, 0.69, 0.65, 0.65], [0.14, 0.31, 0.86, 0.74], [0.77, 0.45, 0.31, 0.31], [0.39, 0.14, 0.99, 0.24], [0.23, 0.32, 0.7, 0.75], [0.65, 0.05, 0.39, 0.49], [0.96, 0.09, 0.49, 0.3], [0.86, 0.03, 0.3, 0.39], [0.5, 0.2, 0.69, 0.95], [0.79, 0.09, 0.41, 0.69], [0.4, 0.3, 0.78, 0.74], [0.65, 0.24, 0.63, 0.27], [0.35, 0.3, 0.94, 0.92], [0.71, 0.78, 0.64, 0.57], [0.8, 0.4, 0.23, 0.33], [0.38, 0.07, 0.82, 0.01], [0.66, 0.09, 0.69, 0.46], [0.54, 0.06, 0.74, 0.86], [0.95, 0.62, 0.28, 0.01], [0.35, 0.71, 0.01, 0.32], [0.62, 0.24, 0.77, 0.17], [0.73, 0.65, 0.23, 0.02], [0.27, 0.38, 0.76, 0.63], [0.9, 0.63, 0.83, 0.6], [0.7, 0.04, 0.7, 0.82], [0.95, 0.83, 0.64, 0.5], [0.41, 0.11, 0.61, 0.78], [0.22, 0.44, 0.67, 0.99], [0.51, 0.05, 0.95, 0.66], [0.99, 0.68, 0.8, 0.42], [0.72, 0.55, 0.1, 0.17], [0.44, 0.1, 0.61, 0.98], [0.31, 0.16, 0.95, 0.9], [0.61, 0.42, 0.24, 0.33], [0.89, 0.72, 0.78, 0.38], [0.5, 0.09, 0.84, 0.78], [0.62, 0.01, 0.88, 0.1], [0.44, 0.28, 0.88, 0.99], [0.57, 0.23, 0.6, 0.85], [0.9, 0.05, 0.34, 0.41], [0.9, 0.41, 0.27, 0.36], [0.67, 0.32, 0.66, 0.2], [0.72, 0.14, 0.63, 0.37], [0.39, 0.08, 0.77, 0.96], [0.9, 0.7, 0.74, 0.63], [0.63, 0.05, 0.52, 0.63], [0.62, 0.27, 0.67, 0.77], [0.35, 0.04, 0.85, 0.86], [0.36, 0.34, 0.75, 0.37]] centroid0 = [ 0.3987179487179487, 0.7097435897435899, 0.6864102564102561, 0.4164102564102565 ] centroid1 = [ 0.7788888888888889, 0.8555555555555555, 0.19666666666666668, 0.788888888888889 ] centroid2 = [ 0.6038461538461538, 0.29865384615384616, 0.6217307692307692, 0.5455769230769231 ] introcs.assert_float_lists_equal(centroid0, cluster0.getCentroid()) introcs.assert_float_lists_equal(centroid1, cluster1.getCentroid()) introcs.assert_float_lists_equal(centroid2, cluster2.getCentroid()) assert_point_sets_equal(contents0, cluster0.getContents()) assert_point_sets_equal(contents1, cluster1.getContents()) assert_point_sets_equal(contents2, cluster2.getContents()) print(' Method Algorithm.step looks okay') print(' Part C of class Algorithm appears correct') print()
def test_cluster_b(): """ Tests Part B of the Cluster class assignment. """ print(' Testing Part B of class Cluster') # A dataset with four points items = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0]] dset = a6dataset.Dataset(3, items) # Create some clusters cluster1 = a6cluster.Cluster(dset, [0.0, 0.0, 0.2]) cluster2 = a6cluster.Cluster(dset, [0.5, 0.5, 0.0]) cluster3 = a6cluster.Cluster(dset, [0.0, 0.0, 0.5]) # TEST CASE 1 (distance) dist = cluster2.distance([1.0, 0.0, -1.0]) introcs.assert_floats_equal(1.22474487139, dist) # TEST CASE 2 (distance) dist = cluster2.distance([0.5, 0.5, 0.0]) introcs.assert_floats_equal(0.0, dist) # TEST CASE 3 (distance) dist = cluster3.distance([0.5, 0.0, 0.5]) introcs.assert_floats_equal(0.5, dist) print(' Method Cluster.distance() looks okay') # Add some indices cluster1.addIndex(0) cluster1.addIndex(1) cluster2.addIndex(0) cluster2.addIndex(1) cluster3.addIndex(0) cluster3.addIndex(1) cluster3.addIndex(2) # TEST CASE 1 (radius) rads = cluster1.getRadius() introcs.assert_floats_equal(1.0198039, rads) # TEST CASE 2 (radius) rads = cluster2.getRadius() introcs.assert_floats_equal(0.7071068, rads) # TEST CASE 3 (radius) rads = cluster3.getRadius() introcs.assert_floats_equal(1.1180340, rads) print(' Method Cluster.getRadius() looks okay') # TEST CASE 1 (updateCentroid): centroid remains the same stable = cluster2.update() introcs.assert_float_lists_equal([0.5, 0.5, 0.0], cluster2.getCentroid()) introcs.assert_true(stable) # TEST CASE 2 (updateCentroid): centroid changes cluster2.addIndex(2) cluster2.addIndex(3) stable = cluster2.update() introcs.assert_float_lists_equal([0.25, 0.25, 0.25], cluster2.getCentroid()) introcs.assert_false(stable) # updating again without changing points: centroid stable stable = cluster2.update() introcs.assert_float_lists_equal([0.25, 0.25, 0.25], cluster2.getCentroid()) introcs.assert_true(stable) print(' Method Cluster.update() looks okay') print(' Part B of class Cluster appears correct') print()
def test_crossout(): """ Test procedure for function crossout(). Note the use of assert_float_lists_equal for testing (nested) lists of floats. """ print('Testing crossout()') table = [[0.1, 0.3, 0.5], [0.6, 0.2, 0.7], [1.5, 2.3, 0.4]] # Snapshot table to make sure we do not modify orig = copy.deepcopy(table) result = funcs.crossout(table, 1, 2) introcs.assert_float_lists_equal([[0.1, 0.3], [1.5, 2.3]], result) introcs.assert_float_lists_equal(orig, table) result = funcs.crossout(table, 0, 0) introcs.assert_float_lists_equal([[0.2, 0.7], [2.3, 0.4]], result) introcs.assert_float_lists_equal(orig, table) result = funcs.crossout(table, 2, 1) introcs.assert_float_lists_equal([[0.1, 0.5], [0.6, 0.7]], result) introcs.assert_float_lists_equal(orig, table) table = [[0.1, 0.3, 0.5], [0.6, 0.2, 0.7], [1.5, 2.3, 0.4], [0.1, 0.2, 0.3]] # Snapshot table to make sure we do not modify orig = copy.deepcopy(table) result = funcs.crossout(table, 1, 2) introcs.assert_float_lists_equal([[0.1, 0.3], [1.5, 2.3], [0.1, 0.2]], result) introcs.assert_float_lists_equal(orig, table) table = [[0.1, 0.3, 0.5, 1.0], [0.6, 0.2, 0.7, 2.0], [1.5, 2.3, 0.4, 3.0]] # Snapshot table to make sure we do not modify orig = copy.deepcopy(table) result = funcs.crossout(table, 1, 2) introcs.assert_float_lists_equal([[0.1, 0.3, 1.0], [1.5, 2.3, 3.0]], result) introcs.assert_float_lists_equal(orig, table) table = [[1, 2], [3, 4]] # Snapshot table to make sure we do not modify orig = copy.deepcopy(table) result = funcs.crossout(table, 1, 0) introcs.assert_float_lists_equal([[2]], result) introcs.assert_float_lists_equal(orig, table) result = funcs.crossout(table, 0, 1) introcs.assert_float_lists_equal([[3]], result) introcs.assert_float_lists_equal(orig, table) table = [[5]] # Snapshot table to make sure we do not modify orig = copy.deepcopy(table) result = funcs.crossout(table, 0, 0) introcs.assert_equals([], result) introcs.assert_float_lists_equal(orig, table)
def test_row_sums(): """ Test procedure for function row_sums(). Note the use of assert_float_lists_equal for testing (nested) lists of floats. """ print('Testing row_sums()') table = [[0.7, 0.0, -0.7, 1.0, -0.9]] # Snapshot table to make sure we do not modify orig = copy.deepcopy(table) result = funcs.row_sums(table) introcs.assert_float_lists_equal([0.1], result) introcs.assert_float_lists_equal(orig, table) table = [[0.7], [0.1], [0.4], [-0.2], [0.6]] # Snapshot table to make sure we do not modify orig = copy.deepcopy(table) result = funcs.row_sums(table) introcs.assert_float_lists_equal([0.7, 0.1, 0.4, -0.2, 0.6], result) introcs.assert_float_lists_equal(orig, table) table = [[0.7, 0.0, -0.7], [0.1, 0.4, -0.6]] # Snapshot table to make sure we do not modify orig = copy.deepcopy(table) result = funcs.row_sums(table) introcs.assert_float_lists_equal([0.0, -0.1], result) introcs.assert_float_lists_equal(orig, table) table = [[0.7, 0.0, -0.7, 1.0, -0.9], [0.1, 0.4, -0.6, 0.9, 0.2], [0.4, -0.1, -0.2, 0.1, -0.6], [-0.2, 0.2, 0.2, -0.3, -0.2], [0.6, -0.1, -0.0, 0.8, 0.9]] # Snapshot table to make sure we do not modify orig = copy.deepcopy(table) result = funcs.row_sums(table) introcs.assert_float_lists_equal([0.1, 1.0, -0.4, -0.3, 2.2], result) introcs.assert_float_lists_equal(orig, table)