diff options
Diffstat (limited to 'elki/src/test/java/de/lmu/ifi/dbs/elki')
205 files changed, 4086 insertions, 394 deletions
diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/AllTests.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/AllTestsTestSuite.java index e4490bba..8809528e 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/AllTests.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/AllTestsTestSuite.java @@ -22,6 +22,8 @@ package de.lmu.ifi.dbs.elki; along with this program. If not, see <http://www.gnu.org/licenses/>. */ +import org.junit.Ignore; + import de.lmu.ifi.dbs.elki.utilities.ELKIServiceRegistry; import junit.framework.JUnit4TestAdapter; import junit.framework.Test; @@ -32,8 +34,9 @@ import junit.framework.TestSuite; * Build a test suite with all tests included with ELKI * * @author Erich Schubert + * @since 0.2 */ -public class AllTests extends TestSuite { +public class AllTestsTestSuite extends TestSuite { /** * Build a test suite with all tests included in ELKI. * @@ -42,7 +45,10 @@ public class AllTests extends TestSuite { public static Test suite() { TestSuite suite = new TestSuite(); for(Class<?> cls : ELKIServiceRegistry.findAllImplementations(TestCase.class, false, false)) { - if(cls == AllTests.class) { + if(cls == AllTestsTestSuite.class) { + continue; + } + if (cls.isAnnotationPresent(Ignore.class)) { continue; } Test test = new JUnit4TestAdapter(cls); @@ -51,7 +57,10 @@ public class AllTests extends TestSuite { } } for(Class<?> cls : ELKIServiceRegistry.findAllImplementations(JUnit4Test.class, false, false)) { - if(cls == AllTests.class) { + if(cls == AllTestsTestSuite.class) { + continue; + } + if (cls.isAnnotationPresent(Ignore.class)) { continue; } Test test = new JUnit4TestAdapter(cls); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/JUnit4Test.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/JUnit4Test.java index 86f72fe0..db347eea 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/JUnit4Test.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/JUnit4Test.java @@ -27,9 +27,10 @@ import org.junit.runner.RunWith; import org.junit.runners.JUnit4; /** - * This interface is used for test-discovery by the {@link AllTests} TestSuite. + * This interface is used for test-discovery by the {@link AllTestsTestSuite} TestSuite. * * @author Erich Schubert + * @since 0.2 */ @RunWith(JUnit4.class) public interface JUnit4Test { diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/AbstractSimpleAlgorithmTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/AbstractSimpleAlgorithmTest.java index 4f92a350..b3911c52 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/AbstractSimpleAlgorithmTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/AbstractSimpleAlgorithmTest.java @@ -60,6 +60,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Abstract base class useful for testing various algorithms. * * @author Erich Schubert + * @since 0.4.0 */ public abstract class AbstractSimpleAlgorithmTest { /** diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/TestKNNJoin.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/KNNJoinTest.java index cf2ca7e0..c30896c3 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/TestKNNJoin.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/KNNJoinTest.java @@ -57,7 +57,13 @@ import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; -public class TestKNNJoin implements JUnit4Test { +/** + * Unit test for kNN joins. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KNNJoinTest implements JUnit4Test { // the following values depend on the data set used! String dataset = "data/testdata/unittests/uebungsblatt-2d-mini.csv"; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/TestDBSCAN.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/DBSCANTest.java index d457600f..7c2b0bce 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/TestDBSCAN.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/DBSCANTest.java @@ -44,8 +44,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * @author Elke Achtert * @author Erich Schubert * @author Katharina Rausch + * @since 0.3 */ -public class TestDBSCAN extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class DBSCANTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run DBSCAN with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/GriDBSCANTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/GriDBSCANTest.java new file mode 100644 index 00000000..4afd3096 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/GriDBSCANTest.java @@ -0,0 +1,118 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.data.model.Model; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Test GriDBSCAN. + * + * @author Erich Schubert + * @since 0.3 + */ +public class GriDBSCANTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run DBSCAN with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testGriDBSCANResults() { + Database db = makeSimpleDatabase(UNITTEST + "3clusters-and-noise-2d.csv", 330); + + // setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(DBSCAN.Parameterizer.EPSILON_ID, 0.04); + params.addParameter(DBSCAN.Parameterizer.MINPTS_ID, 20); + params.addParameter(GriDBSCAN.Parameterizer.GRID_ID, 0.08); + GriDBSCAN<DoubleVector> dbscan = ClassGenericsUtil.parameterizeOrAbort(GriDBSCAN.class, params); + testParameterizationOk(params); + + // run DBSCAN on database + Clustering<Model> result = dbscan.run(db); + + testFMeasure(db, result, 0.996413); + testClusterSizes(result, new int[] { 29, 50, 101, 150 }); + } + + /** + * Run DBSCAN with fixed parameters and compare the result to a golden + * standard, with larger grid width (fewer cells, less redundancy). + * + * @throws ParameterException + */ + @Test + public void testGriDBSCANWide() { + Database db = makeSimpleDatabase(UNITTEST + "3clusters-and-noise-2d.csv", 330); + + // setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(DBSCAN.Parameterizer.EPSILON_ID, 0.04); + params.addParameter(DBSCAN.Parameterizer.MINPTS_ID, 20); + params.addParameter(GriDBSCAN.Parameterizer.GRID_ID, 0.4); + GriDBSCAN<DoubleVector> dbscan = ClassGenericsUtil.parameterizeOrAbort(GriDBSCAN.class, params); + testParameterizationOk(params); + + // run DBSCAN on database + Clustering<Model> result = dbscan.run(db); + + testFMeasure(db, result, 0.996413); + testClusterSizes(result, new int[] { 29, 50, 101, 150 }); + } + + /** + * Run DBSCAN with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testDBSCANOnSingleLinkDataset() { + Database db = makeSimpleDatabase(UNITTEST + "single-link-effect.ascii", 638); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(DBSCAN.Parameterizer.EPSILON_ID, 11.5); + params.addParameter(DBSCAN.Parameterizer.MINPTS_ID, 120); + params.addParameter(GriDBSCAN.Parameterizer.GRID_ID, 25.); + GriDBSCAN<DoubleVector> dbscan = ClassGenericsUtil.parameterizeOrAbort(GriDBSCAN.class, params); + testParameterizationOk(params); + + // run DBSCAN on database + Clustering<Model> result = dbscan.run(db); + testFMeasure(db, result, 0.954382); + testClusterSizes(result, new int[] { 11, 200, 203, 224 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/TestSNNClusteringResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/SNNClusteringTest.java index ca47b2e2..ecdb8a90 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/TestSNNClusteringResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/SNNClusteringTest.java @@ -44,8 +44,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestSNNClusteringResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class SNNClusteringTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run SNNClustering with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/AffinityPropagationClusteringAlgorithmTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/AffinityPropagationClusteringAlgorithmTest.java new file mode 100644 index 00000000..41a4d7d4 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/AffinityPropagationClusteringAlgorithmTest.java @@ -0,0 +1,111 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.affinitypropagation; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.data.model.MedoidModel; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel.PolynomialKernelFunction; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Test Affinity Propagation + * + * @author Erich Schubert + * @since 0.7.1 + */ +public class AffinityPropagationClusteringAlgorithmTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run AffinityPropagationClusteringAlgorithm with fixed parameters and + * compare the result to a golden standard. + * + * @throws ParameterException + */ + @Test + public void testAffinityPropagationClusteringAlgorithmResults() { + Database db = makeSimpleDatabase(UNITTEST + "3clusters-and-noise-2d.csv", 330); + + // setup algorithm + ListParameterization params = new ListParameterization(); + AffinityPropagationClusteringAlgorithm<DoubleVector> apc = ClassGenericsUtil.parameterizeOrAbort(AffinityPropagationClusteringAlgorithm.class, params); + testParameterizationOk(params); + + // run AffinityPropagationClusteringAlgorithm on database + Clustering<MedoidModel> result = apc.run(db); + + testFMeasure(db, result, 0.957227259); + testClusterSizes(result, new int[] { 5, 5, 7, 55, 105, 153 }); + } + + /** + * Run AffinityPropagationClusteringAlgorithm with fixed parameters and + * compare the result to a golden standard. + * + * @throws ParameterException + */ + @Test + public void testAffinityPropagationClusteringAlgorithmOnSingleLinkDataset() { + Database db = makeSimpleDatabase(UNITTEST + "single-link-effect.ascii", 638); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + AffinityPropagationClusteringAlgorithm<DoubleVector> apc = ClassGenericsUtil.parameterizeOrAbort(AffinityPropagationClusteringAlgorithm.class, params); + testParameterizationOk(params); + + // run AffinityPropagationClusteringAlgorithm on database + Clustering<MedoidModel> result = apc.run(db); + testFMeasure(db, result, 0.351689882); + testClusterSizes(result, new int[] { 24, 27, 29, 34, 36, 36, 37, 38, 41, 43, 43, 44, 46, 47, 56, 57 }); + } + + /** + * Run AffinityPropagationClusteringAlgorithm with fixed parameters and + * compare the result to a golden standard. + * + * @throws ParameterException + */ + @Test + public void testAffinityPropagationSimilarity() { + Database db = makeSimpleDatabase(UNITTEST + "single-link-effect.ascii", 638); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(AffinityPropagationClusteringAlgorithm.Parameterizer.INITIALIZATION_ID, SimilarityBasedInitializationWithMedian.class); + params.addParameter(SimilarityBasedInitializationWithMedian.Parameterizer.SIMILARITY_ID, PolynomialKernelFunction.class); + AffinityPropagationClusteringAlgorithm<DoubleVector> apc = ClassGenericsUtil.parameterizeOrAbort(AffinityPropagationClusteringAlgorithm.class, params); + testParameterizationOk(params); + + // run AffinityPropagationClusteringAlgorithm on database + Clustering<MedoidModel> result = apc.run(db); + testFMeasure(db, result, 0.352103); + testClusterSizes(result, new int[] { 20, 30, 32, 33, 34, 35, 36, 39, 39, 40, 43, 45, 45, 49, 49, 69 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/TestCASHResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/CASHTest.java index e9f9f228..b0c225bf 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/TestCASHResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/CASHTest.java @@ -39,11 +39,12 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * from the data set labels. This test ensures that CASH performance doesn't * unexpectedly drop on this data set (and also ensures that the algorithms * work, as a side effect). - * + * * @author Erich Schubert * @author Katharina Rausch + * @since 0.2 */ -public class TestCASHResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class CASHTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run CASH with fixed parameters and compare the result to a golden standard. */ @@ -54,10 +55,10 @@ public class TestCASHResults extends AbstractSimpleAlgorithmTest implements JUni // CASH parameters ListParameterization params = new ListParameterization(); - params.addParameter(CASH.JITTER_ID, 0.7); - params.addParameter(CASH.MINPTS_ID, 50); - params.addParameter(CASH.MAXLEVEL_ID, 25); - params.addFlag(CASH.ADJUST_ID); + params.addParameter(CASH.Parameterizer.JITTER_ID, 0.7); + params.addParameter(CASH.Parameterizer.MINPTS_ID, 50); + params.addParameter(CASH.Parameterizer.MAXLEVEL_ID, 25); + params.addFlag(CASH.Parameterizer.ADJUST_ID); // setup algorithm CASH<DoubleVector> cash = ClassGenericsUtil.parameterizeOrAbort(CASH.class, params); @@ -80,9 +81,9 @@ public class TestCASHResults extends AbstractSimpleAlgorithmTest implements JUni // CASH parameters ListParameterization params = new ListParameterization(); - params.addParameter(CASH.JITTER_ID, 0.7); - params.addParameter(CASH.MINPTS_ID, 160); - params.addParameter(CASH.MAXLEVEL_ID, 40); + params.addParameter(CASH.Parameterizer.JITTER_ID, 0.7); + params.addParameter(CASH.Parameterizer.MINPTS_ID, 160); + params.addParameter(CASH.Parameterizer.MAXLEVEL_ID, 40); // setup algorithm CASH<DoubleVector> cash = ClassGenericsUtil.parameterizeOrAbort(CASH.class, params); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/TestCOPACResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/COPACTest.java index f3b06c81..95503656 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/TestCOPACResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/COPACTest.java @@ -46,15 +46,16 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * from the data set labels. This test ensures that COPAC performance doesn't * unexpectedly drop on this data set (and also ensures that the algorithms * work, as a side effect). - * + * * @author Erich Schubert * @author Katharina Rausch + * @since 0.3 */ -public class TestCOPACResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class COPACTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run COPAC with fixed parameters and compare the result to a golden * standard. - * + * * @throws ParameterException on errors. */ @Test @@ -80,7 +81,7 @@ public class TestCOPACResults extends AbstractSimpleAlgorithmTest implements JUn /** * Run COPAC with fixed parameters and compare the result to a golden * standard. - * + * * @throws ParameterException on errors. */ @Test @@ -93,10 +94,10 @@ public class TestCOPACResults extends AbstractSimpleAlgorithmTest implements JUn params.addParameter(DBSCAN.Parameterizer.MINPTS_ID, 20); params.addParameter(COPAC.Settings.Parameterizer.K_ID, 45); // PCA - params.addParameter(PCARunner.PCA_COVARIANCE_MATRIX, WeightedCovarianceMatrixBuilder.class); - params.addParameter(WeightedCovarianceMatrixBuilder.WEIGHT_ID, ErfcWeight.class); + params.addParameter(PCARunner.Parameterizer.PCA_COVARIANCE_MATRIX, WeightedCovarianceMatrixBuilder.class); + params.addParameter(WeightedCovarianceMatrixBuilder.Parameterizer.WEIGHT_ID, ErfcWeight.class); params.addParameter(PCAFilteredRunner.Parameterizer.PCA_EIGENPAIR_FILTER, PercentageEigenPairFilter.class); - params.addParameter(PercentageEigenPairFilter.ALPHA_ID, 0.8); + params.addParameter(PercentageEigenPairFilter.Parameterizer.ALPHA_ID, 0.8); COPAC<DoubleVector> copac = ClassGenericsUtil.parameterizeOrAbort(COPAC.class, params); testParameterizationOk(params); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/TestERiCResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ERiCTest.java index 7f2fb737..268fc827 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/TestERiCResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ERiCTest.java @@ -47,14 +47,15 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * from the data set labels. This test ensures that ERiC performance doesn't * unexpectedly drop on this data set (and also ensures that the algorithms * work, as a side effect). - * + * * @author Erich Schubert * @author Katharina Rausch + * @since 0.2 */ -public class TestERiCResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class ERiCTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run ERiC with fixed parameters and compare the result to a golden standard. - * + * * @throws ParameterException on errors. */ @Test @@ -69,10 +70,10 @@ public class TestERiCResults extends AbstractSimpleAlgorithmTest implements JUni params.addParameter(ERiC.Settings.Parameterizer.TAU_ID, 0.04); params.addParameter(ERiC.Settings.Parameterizer.K_ID, 50); // PCA - params.addParameter(PCARunner.PCA_COVARIANCE_MATRIX, WeightedCovarianceMatrixBuilder.class); - params.addParameter(WeightedCovarianceMatrixBuilder.WEIGHT_ID, ErfcWeight.class); + params.addParameter(PCARunner.Parameterizer.PCA_COVARIANCE_MATRIX, WeightedCovarianceMatrixBuilder.class); + params.addParameter(WeightedCovarianceMatrixBuilder.Parameterizer.WEIGHT_ID, ErfcWeight.class); params.addParameter(PCAFilteredRunner.Parameterizer.PCA_EIGENPAIR_FILTER, RelativeEigenPairFilter.class); - params.addParameter(RelativeEigenPairFilter.EIGENPAIR_FILTER_RALPHA, 1.60); + params.addParameter(RelativeEigenPairFilter.Parameterizer.EIGENPAIR_FILTER_RALPHA, 1.60); ERiC<DoubleVector> eric = ClassGenericsUtil.parameterizeOrAbort(ERiC.class, params); testParameterizationOk(params); @@ -86,7 +87,7 @@ public class TestERiCResults extends AbstractSimpleAlgorithmTest implements JUni /** * Run ERiC with fixed parameters and compare the result to a golden standard. - * + * * @throws ParameterException on errors. */ @Test @@ -102,10 +103,10 @@ public class TestERiCResults extends AbstractSimpleAlgorithmTest implements JUni params.addParameter(ERiC.Settings.Parameterizer.TAU_ID, 1.0); params.addParameter(ERiC.Settings.Parameterizer.K_ID, 45); // PCA - params.addParameter(PCARunner.PCA_COVARIANCE_MATRIX, WeightedCovarianceMatrixBuilder.class); - params.addParameter(WeightedCovarianceMatrixBuilder.WEIGHT_ID, ErfcWeight.class); + params.addParameter(PCARunner.Parameterizer.PCA_COVARIANCE_MATRIX, WeightedCovarianceMatrixBuilder.class); + params.addParameter(WeightedCovarianceMatrixBuilder.Parameterizer.WEIGHT_ID, ErfcWeight.class); params.addParameter(PCAFilteredRunner.Parameterizer.PCA_EIGENPAIR_FILTER, PercentageEigenPairFilter.class); - params.addParameter(PercentageEigenPairFilter.ALPHA_ID, 0.6); + params.addParameter(PercentageEigenPairFilter.Parameterizer.ALPHA_ID, 0.6); ERiC<DoubleVector> eric = ClassGenericsUtil.parameterizeOrAbort(ERiC.class, params); testParameterizationOk(params); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/TestFourCResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/FourCTest.java index 8bfa5962..ddfe8218 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/TestFourCResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/FourCTest.java @@ -42,14 +42,15 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * the data set labels. This test ensures that 4C performance doesn't * unexpectedly drop on this data set (and also ensures that the algorithms * work, as a side effect). - * + * * @author Erich Schubert * @author Katharina Rausch + * @since 0.3 */ -public class TestFourCResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class FourCTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run 4F with fixed parameters and compare the result to a golden standard. - * + * * @throws ParameterException on errors. */ @Test @@ -60,7 +61,7 @@ public class TestFourCResults extends AbstractSimpleAlgorithmTest implements JUn ListParameterization params = new ListParameterization(); params.addParameter(DBSCAN.Parameterizer.EPSILON_ID, 0.30); params.addParameter(DBSCAN.Parameterizer.MINPTS_ID, 50); - params.addParameter(LimitEigenPairFilter.EIGENPAIR_FILTER_DELTA, 0.5); + params.addParameter(LimitEigenPairFilter.Parameterizer.EIGENPAIR_FILTER_DELTA, 0.5); params.addParameter(FourC.Settings.Parameterizer.LAMBDA_ID, 1); FourC<DoubleVector> fourc = ClassGenericsUtil.parameterizeOrAbort(FourC.class, params); @@ -75,7 +76,7 @@ public class TestFourCResults extends AbstractSimpleAlgorithmTest implements JUn /** * Run ERiC with fixed parameters and compare the result to a golden standard. - * + * * @throws ParameterException on errors. */ @Test @@ -87,7 +88,7 @@ public class TestFourCResults extends AbstractSimpleAlgorithmTest implements JUn // 4C params.addParameter(DBSCAN.Parameterizer.EPSILON_ID, 3); params.addParameter(DBSCAN.Parameterizer.MINPTS_ID, 50); - params.addParameter(LimitEigenPairFilter.EIGENPAIR_FILTER_DELTA, 0.5); + params.addParameter(LimitEigenPairFilter.Parameterizer.EIGENPAIR_FILTER_DELTA, 0.5); params.addParameter(FourC.Settings.Parameterizer.LAMBDA_ID, 3); FourC<DoubleVector> fourc = ClassGenericsUtil.parameterizeOrAbort(FourC.class, params); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/LMCLUSTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/LMCLUSTest.java new file mode 100644 index 00000000..e3744626 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/LMCLUSTest.java @@ -0,0 +1,87 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.correlation; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.model.Model; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Test the LMCLUS algorithm. + * + * @author Erich Schubert + * @since 0.3 + */ +public class LMCLUSTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run 4F with fixed parameters and compare the result to a golden standard. + * + * @throws ParameterException on errors. + */ + @Test + public void testLMCLUSResults() { + Database db = makeSimpleDatabase(UNITTEST + "hierarchical-3d2d1d.csv", 600); + + ListParameterization params = new ListParameterization(); + params.addParameter(LMCLUS.Parameterizer.MINSIZE_ID, 100); + params.addParameter(LMCLUS.Parameterizer.THRESHOLD_ID, 10); + params.addParameter(LMCLUS.Parameterizer.RANDOM_ID, 0); + + LMCLUS lmclus = ClassGenericsUtil.parameterizeOrAbort(LMCLUS.class, params); + testParameterizationOk(params); + + Clustering<Model> result = lmclus.run(db); + testFMeasure(db, result, 0.43327638); + testClusterSizes(result, new int[] { 201, 399 }); + } + + /** + * Run ERiC with fixed parameters and compare the result to a golden standard. + * + * @throws ParameterException on errors. + */ + @Test + public void testLMCLUSOverlap() { + Database db = makeSimpleDatabase(UNITTEST + "correlation-overlap-3-5d.ascii", 650); + + ListParameterization params = new ListParameterization(); + params.addParameter(LMCLUS.Parameterizer.MINSIZE_ID, 100); + params.addParameter(LMCLUS.Parameterizer.THRESHOLD_ID, 10); + params.addParameter(LMCLUS.Parameterizer.RANDOM_ID, 0); + + LMCLUS lmclus = ClassGenericsUtil.parameterizeOrAbort(LMCLUS.class, params); + testParameterizationOk(params); + + Clustering<Model> result = lmclus.run(db); + testClusterSizes(result, new int[] { 196, 454 }); + testFMeasure(db, result, 0.6547222); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/TestORCLUSResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ORCLUSTest.java index cd6d4558..f71f863a 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/TestORCLUSResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ORCLUSTest.java @@ -43,8 +43,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Elke Achtert * @author Katharina Rausch + * @since 0.3 */ -public class TestORCLUSResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class ORCLUSTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run ORCLUS with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/TestEMResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EMTest.java index 629a78d5..0ede15bb 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/TestEMResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EMTest.java @@ -32,7 +32,6 @@ import de.lmu.ifi.dbs.elki.data.Clustering; import de.lmu.ifi.dbs.elki.data.DoubleVector; import de.lmu.ifi.dbs.elki.database.Database; import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; /** @@ -40,15 +39,14 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * from the data set labels. This test ensures that EM's performance doesn't * unexpectedly drop on this data set (and also ensures that the algorithms * work, as a side effect). - * + * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestEMResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class EMTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run EM with fixed parameters and compare the result to a golden standard. - * - * @throws ParameterException */ @Test public void testEMResults() { @@ -63,7 +61,49 @@ public class TestEMResults extends AbstractSimpleAlgorithmTest implements JUnit4 // run EM on database Clustering<?> result = em.run(db); - testFMeasure(db, result, 0.781737); - testClusterSizes(result, new int[] { 2, 5, 17, 175, 200, 311 }); + testFMeasure(db, result, 0.780036); + testClusterSizes(result, new int[] { 2, 5, 27, 171, 200, 305 }); + } + + /** + * Run EM with fixed parameters and compare the result to a golden standard. + */ + @Test + public void testEMResultsDiagonal() { + Database db = makeSimpleDatabase(UNITTEST + "hierarchical-2d.ascii", 710); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.SEED_ID, 0); + params.addParameter(EM.Parameterizer.K_ID, 6); + params.addParameter(EM.Parameterizer.INIT_ID, DiagonalGaussianModelFactory.class); + EM<DoubleVector, ?> em = ClassGenericsUtil.parameterizeOrAbort(EM.class, params); + testParameterizationOk(params); + + // run EM on database + Clustering<?> result = em.run(db); + testFMeasure(db, result, 0.9302319); + testClusterSizes(result, new int[] { 7, 22, 93, 97, 200, 291 }); + } + + /** + * Run EM with fixed parameters and compare the result to a golden standard. + */ + @Test + public void testEMResultsSpherical() { + Database db = makeSimpleDatabase(UNITTEST + "hierarchical-2d.ascii", 710); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.SEED_ID, 0); + params.addParameter(EM.Parameterizer.K_ID, 6); + params.addParameter(EM.Parameterizer.INIT_ID, SphericalGaussianModelFactory.class); + EM<DoubleVector, ?> em = ClassGenericsUtil.parameterizeOrAbort(EM.class, params); + testParameterizationOk(params); + + // run EM on database + Clustering<?> result = em.run(db); + testFMeasure(db, result, 0.514850); + testClusterSizes(result, new int[] { 0, 6, 53, 69, 191, 391 }); } }
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/TestGeneralizedDBSCAN.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/GeneralizedDBSCANTest.java index c5bb1c5e..3c77f029 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/TestGeneralizedDBSCAN.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/GeneralizedDBSCANTest.java @@ -44,8 +44,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * @author Elke Achtert * @author Erich Schubert * @author Katharina Rausch + * @since 0.3 */ -public class TestGeneralizedDBSCAN extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class GeneralizedDBSCANTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run Generalized DBSCAN with fixed parameters and compare the result to a * golden standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/LSDBCTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/LSDBCTest.java new file mode 100644 index 00000000..c33ba0e7 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/LSDBCTest.java @@ -0,0 +1,78 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.gdbscan; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.data.model.Model; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Regression test for LSDBC. + * + * @author Erich Schubert + * @since 0.3 + */ +public class LSDBCTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testLSDBCResults() { + Database db = makeSimpleDatabase(UNITTEST + "3clusters-and-noise-2d.csv", 330); + + // setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(LSDBC.Parameterizer.ALPHA_ID, 0.4); + params.addParameter(LSDBC.Parameterizer.K_ID, 20); + LSDBC<DoubleVector> dbscan = ClassGenericsUtil.parameterizeOrAbort(LSDBC.class, params); + testParameterizationOk(params); + + // run LSDBC on database + Clustering<Model> result = dbscan.run(db); + + testFMeasure(db, result, 0.44848979); + testClusterSizes(result, new int[] { 38, 38, 41, 54, 159 }); + } + + @Test + public void testLSDBCOnSingleLinkDataset() { + Database db = makeSimpleDatabase(UNITTEST + "single-link-effect.ascii", 638); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(LSDBC.Parameterizer.ALPHA_ID, 0.2); + params.addParameter(LSDBC.Parameterizer.K_ID, 120); + LSDBC<DoubleVector> dbscan = ClassGenericsUtil.parameterizeOrAbort(LSDBC.class, params); + testParameterizationOk(params); + + // run LSDBC on database + Clustering<Model> result = dbscan.run(db); + testFMeasure(db, result, 0.95681073); + testClusterSizes(result, new int[] { 32, 197, 203, 206 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/TestAGNES.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AGNESTest.java index f12ae73d..c0421a54 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/TestAGNES.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AGNESTest.java @@ -39,8 +39,9 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * Perform agglomerative hierarchical clustering, using the naive algorithm. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestAGNES extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class AGNESTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { // TODO: add more data sets. /** diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/TestAnderbergHierarchicalClustering.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AnderbergHierarchicalClusteringTest.java index 6dd73ec6..c94557dd 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/TestAnderbergHierarchicalClustering.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AnderbergHierarchicalClusteringTest.java @@ -40,8 +40,9 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * algorithm. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestAnderbergHierarchicalClustering extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class AnderbergHierarchicalClusteringTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { // TODO: add more data sets. /** diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/TestCLINKResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CLINKTest.java index d9276c5b..b6ce8545 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/TestCLINKResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CLINKTest.java @@ -42,8 +42,9 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * work, as a side effect). * * @author Erich Schubert + * @since 0.4.0 */ -public class TestCLINKResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class CLINKTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run CLINK with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/TestSLINKResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SLINKTest.java index 22b143a4..bde1e243 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/TestSLINKResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SLINKTest.java @@ -43,8 +43,9 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestSLINKResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class SLINKTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { // TODO: add a test for a non-single-link dataset? /** diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestCLARA.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/CLARATest.java index f9c0b779..89599bda 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestCLARA.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/CLARATest.java @@ -43,8 +43,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestCLARA extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class CLARATest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run CLARA with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBatchedLloydTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBatchedLloydTest.java new file mode 100644 index 00000000..bab15c09 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBatchedLloydTest.java @@ -0,0 +1,68 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Regression test for batched Lloyd k-means. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansBatchedLloydTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testKMeansBatchedLloyd() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 2); + params.addParameter(KMeansBatchedLloyd.Parameterizer.BLOCKS_ID, 10); + params.addParameter(KMeansBatchedLloyd.Parameterizer.RANDOM_ID, 0); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansBatchedLloyd.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.998005); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansBisecting.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBisectingTest.java index 06d55028..cb407e28 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansBisecting.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBisectingTest.java @@ -39,8 +39,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the KMeansBisecting * * @author Stephan Baier + * @since 0.6.0 */ -public class TestKMeansBisecting extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMeansBisectingTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeansBisecting with fixed parameters and compare cluster size to * expected value. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansCompareTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansCompareTest.java new file mode 100644 index 00000000..fead9461 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansCompareTest.java @@ -0,0 +1,66 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Regression test for Compare k-means. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansCompareTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testKMeansCompare() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 2); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansCompare.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.998005); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansElkan.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansElkanTest.java index 95f28c5d..2d1cbe5a 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansElkan.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansElkanTest.java @@ -35,26 +35,27 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; /** - * Regression test for Hamerly k-means. - * + * Regression test for Elkan k-means. + * * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMeansElkan extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMeansElkanTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeans with fixed parameters and compare the result to a golden * standard. - * + * * @throws ParameterException */ @Test - public void testKMeansLloyd() { + public void testKMeansElkan() { Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); // Setup algorithm ListParameterization params = new ListParameterization(); params.addParameter(KMeans.K_ID, 5); params.addParameter(KMeans.SEED_ID, 2); - AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansHamerly.class, params); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansElkan.class, params); testParameterizationOk(params); // run KMeans on database diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansHamerly.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHamerlyTest.java index e709861e..328211fb 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansHamerly.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHamerlyTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Regression test for Hamerly k-means. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMeansHamerly extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMeansHamerlyTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeans with fixed parameters and compare the result to a golden * standard. @@ -47,7 +48,7 @@ public class TestKMeansHamerly extends AbstractSimpleAlgorithmTest implements JU * @throws ParameterException */ @Test - public void testKMeansLloyd() { + public void testKMeansHamerly() { Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); // Setup algorithm diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHybridLloydMacQueenTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHybridLloydMacQueenTest.java new file mode 100644 index 00000000..390f5c3d --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHybridLloydMacQueenTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a full KMeans run, and compares the result with a clustering derived + * from the data set labels. This test ensures that KMeans's performance doesn't + * unexpectedly drop on this data set (and also ensures that the algorithms + * work, as a side effect). + * + * @author Katharina Rausch + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansHybridLloydMacQueenTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testKMeansHybridLloydMacQueen() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 2); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansHybridLloydMacQueen.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.998005); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansLloyd.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansLloydTest.java index 15d73657..a0edbe5e 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansLloyd.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansLloydTest.java @@ -42,8 +42,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMeansLloyd extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMeansLloydTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeans with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansMacQueen.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansMacQueenTest.java index b4289b9f..6271929d 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMeansMacQueen.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansMacQueenTest.java @@ -42,8 +42,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMeansMacQueen extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMeansMacQueenTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeans with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansSortTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansSortTest.java new file mode 100644 index 00000000..b7b20097 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansSortTest.java @@ -0,0 +1,66 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Regression test for Sort-means. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansSortTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testKMeansSort() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 2); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(KMeansSort.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.998005); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMediansLloyd.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMediansLloydTest.java index ab451cab..c7abf806 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMediansLloyd.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMediansLloydTest.java @@ -42,8 +42,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMediansLloyd extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMediansLloydTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMedians with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMedoidsEM.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsEMTest.java index ecfafffe..eee1c799 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMedoidsEM.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsEMTest.java @@ -41,8 +41,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMedoidsEM extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMedoidsEMTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMedoidsEM with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMedoidsPAM.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsPAMTest.java index 4bb98041..a7fe2712 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestKMedoidsPAM.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsPAMTest.java @@ -43,8 +43,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestKMedoidsPAM extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KMedoidsPAMTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMedians PAM with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/SingleAssignmentKMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/SingleAssignmentKMeansTest.java new file mode 100644 index 00000000..c20790b9 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/SingleAssignmentKMeansTest.java @@ -0,0 +1,67 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a full KMeans run, and compares the result with a clustering derived + * from the data set labels. This test ensures that KMeans's performance doesn't + * unexpectedly drop on this data set (and also ensures that the algorithms + * work, as a side effect). + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class SingleAssignmentKMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + */ + @Test + public void testSingleAssignmentKMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + // Unsurprisingly, these results are much worse than normal k-means + testFMeasure(db, result, 0.7936860577); + testClusterSizes(result, new int[] { 52, 151, 200, 201, 396 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestXMeans.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/XMeansTest.java index 58871f75..91ec25e2 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/TestXMeans.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/XMeansTest.java @@ -39,8 +39,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Tibor Goldschwendt * @author Erich Schubert + * @since 0.4.0 */ -public class TestXMeans extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class XMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testXMeans() { Database db = makeSimpleDatabase(UNITTEST + "3clusters-and-noise-2d.csv", 330); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestPointsInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestPointsInitialMeansTest.java new file mode 100644 index 00000000..f077abf7 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestPointsInitialMeansTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class FarthestPointsInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testFarthestPointsInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, FarthestPointsInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.88132453); + testClusterSizes(result, new int[] { 128, 199, 201, 201, 271 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestSumPointsInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestSumPointsInitialMeansTest.java new file mode 100644 index 00000000..2f592fb3 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestSumPointsInitialMeansTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class FarthestSumPointsInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testFarthestSumPointsInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, FarthestSumPointsInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.80399668933); + testClusterSizes(result, new int[] { 32, 169, 199, 201, 399 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FirstKInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FirstKInitialMeansTest.java new file mode 100644 index 00000000..dbcd91da --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FirstKInitialMeansTest.java @@ -0,0 +1,69 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class FirstKInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testFirstKInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.INIT_ID, FirstKInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.62025907); + testClusterSizes(result, new int[] { 23, 38, 226, 258, 455 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansPlusPlusInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansPlusPlusInitialMeansTest.java new file mode 100644 index 00000000..0b9355e3 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansPlusPlusInitialMeansTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansPlusPlusInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testSingleAssignmentKMeansPlusPlus() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, KMeansPlusPlusInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.99800500); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PAMInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PAMInitialMeansTest.java new file mode 100644 index 00000000..c0d2b46d --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PAMInitialMeansTest.java @@ -0,0 +1,69 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class PAMInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testPAMInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.INIT_ID, PAMInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.99800500); + testClusterSizes(result, new int[] { 199, 200, 200, 200, 201 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyChosenInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyChosenInitialMeansTest.java new file mode 100644 index 00000000..a1e36fde --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyChosenInitialMeansTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class RandomlyChosenInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testRandomlyChosenInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, RandomlyChosenInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.793686); + testClusterSizes(result, new int[] { 52, 151, 200, 201, 396 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyGeneratedInitialMeansTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyGeneratedInitialMeansTest.java new file mode 100644 index 00000000..045e6b4f --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyGeneratedInitialMeansTest.java @@ -0,0 +1,70 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class RandomlyGeneratedInitialMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testRandomlyGeneratedInitialMeans() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, RandomlyGeneratedInitialMeans.class); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.7597720973); + testClusterSizes(result, new int[] { 66, 200, 200, 245, 289 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/SampleKMeansInitializationTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/SampleKMeansInitializationTest.java new file mode 100644 index 00000000..9d9e4a2a --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/SampleKMeansInitializationTest.java @@ -0,0 +1,74 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.AbstractKMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansHamerly; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SingleAssignmentKMeans; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Performs a single assignment with different k-means initializations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class SampleKMeansInitializationTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run KMeans with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testSampleKMeansInitialization() { + Database db = makeSimpleDatabase(UNITTEST + "different-densities-2d-no-noise.ascii", 1000); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(KMeans.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(KMeans.INIT_ID, SampleKMeansInitialization.class); + params.addParameter(SampleKMeansInitialization.Parameterizer.KMEANS_ID, KMeansHamerly.class); + params.addParameter(KMeans.SEED_ID, 3); + params.addParameter(SampleKMeansInitialization.Parameterizer.SAMPLE_ID, 100); + AbstractKMeans<DoubleVector, ?> kmeans = ClassGenericsUtil.parameterizeOrAbort(SingleAssignmentKMeans.class, params); + testParameterizationOk(params); + + // run KMeans on database + Clustering<?> result = kmeans.run(db); + testFMeasure(db, result, 0.780753320); + testClusterSizes(result, new int[] { 75, 125, 200, 205, 395 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/TestParallelLloydKMeans.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/ParallelLloydKMeansTest.java index a396cf73..cf6151cf 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/TestParallelLloydKMeans.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/ParallelLloydKMeansTest.java @@ -44,8 +44,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestParallelLloydKMeans extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class ParallelLloydKMeansTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run KMeans with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/TestWithinClusterMeanDistanceQualityMeasure.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterMeanDistanceQualityMeasureTest.java index f4531305..d2f619e7 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/TestWithinClusterMeanDistanceQualityMeasure.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterMeanDistanceQualityMeasureTest.java @@ -47,8 +47,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Test cluster quality measure computations. * * @author Stephan Baier + * @since 0.6.0 */ -public class TestWithinClusterMeanDistanceQualityMeasure extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class WithinClusterMeanDistanceQualityMeasureTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Test cluster average overall distance. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/TestWithinClusterVarianceQualityMeasure.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterVarianceQualityMeasureTest.java index 57b6ba75..eee4bf74 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/TestWithinClusterVarianceQualityMeasure.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterVarianceQualityMeasureTest.java @@ -47,8 +47,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Test cluster quality measure computations. * * @author Stephan Baier + * @since 0.6.0 */ -public class TestWithinClusterVarianceQualityMeasure extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class WithinClusterVarianceQualityMeasureTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Test cluster variance. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/TestDeLiCluResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/DeLiCluTest.java index 51879af4..2773a61e 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/TestDeLiCluResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/DeLiCluTest.java @@ -49,8 +49,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestDeLiCluResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class DeLiCluTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run DeLiClu with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/FastOPTICSTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/FastOPTICSTest.java new file mode 100644 index 00000000..3b00856a --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/FastOPTICSTest.java @@ -0,0 +1,62 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.optics; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.index.preprocessed.fastoptics.RandomProjectedNeighborsAndDensities; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Simple regression test for FastOPTICS. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class FastOPTICSTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testFastOPTICS() { + Database db = makeSimpleDatabase(UNITTEST + "hierarchical-2d.ascii", 710); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(OPTICSList.Parameterizer.MINPTS_ID, 18); + params.addParameter(OPTICSXi.Parameterizer.XI_ID, 0.038); + params.addParameter(OPTICSXi.Parameterizer.XIALG_ID, FastOPTICS.class); + params.addParameter(RandomProjectedNeighborsAndDensities.Parameterizer.RANDOM_ID, 0); + OPTICSXi opticsxi = ClassGenericsUtil.parameterizeOrAbort(OPTICSXi.class, params); + testParameterizationOk(params); + + // run OPTICS on database + Clustering<?> clustering = opticsxi.run(db); + + testFMeasure(db, clustering, 0.7495221); + testClusterSizes(clustering, new int[] { 3, 4, 5, 6, 7, 8, 13, 18, 23, 26, 36, 40, 42, 95, 167, 217 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/TestOPTICSHeapResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSHeapTest.java index f318636d..d47e5ea2 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/TestOPTICSHeapResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSHeapTest.java @@ -41,8 +41,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestOPTICSHeapResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class OPTICSHeapTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run OPTICS with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/TestOPTICSListResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSListTest.java index 249c3cad..27125ad9 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/TestOPTICSListResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSListTest.java @@ -41,8 +41,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Katharina Rausch * @author Erich Schubert + * @since 0.4.0 */ -public class TestOPTICSListResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class OPTICSListTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run OPTICS with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestCLIQUEResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/CLIQUETest.java index 25019d7a..b71bd57b 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestCLIQUEResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/CLIQUETest.java @@ -40,16 +40,17 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * from the data set labels. This test ensures that CLIQUE performance doesn't * unexpectedly drop on this data set (and also ensures that the algorithms * work, as a side effect). - * + * * @author Elke Achtert * @author Katharina Rausch * @author Erich Schubert + * @since 0.3 */ -public class TestCLIQUEResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class CLIQUETest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run CLIQUE with fixed parameters and compare the result to a golden * standard. - * + * * @throws ParameterException */ @Test @@ -75,7 +76,7 @@ public class TestCLIQUEResults extends AbstractSimpleAlgorithmTest implements JU /** * Run CLIQUE with fixed parameters and compare the result to a golden * standard. - * + * * @throws ParameterException */ @Test @@ -95,4 +96,29 @@ public class TestCLIQUEResults extends AbstractSimpleAlgorithmTest implements JU // testFMeasure(db, result, 0.433661); testClusterSizes(result, new int[] { 255, 409, 458, 458, 480 }); } + + /** + * Run CLIQUE with fixed parameters and compare the result to a golden + * standard. + * + * @throws ParameterException + */ + @Test + public void testCLIQUESubspaceOverlappingPrune() { + Database db = makeSimpleDatabase(UNITTEST + "subspace-overlapping-3-4d.ascii", 850); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(CLIQUE.TAU_ID, 0.2); + params.addParameter(CLIQUE.XSI_ID, 6); + params.addFlag(CLIQUE.PRUNE_ID); + CLIQUE<DoubleVector> clique = ClassGenericsUtil.parameterizeOrAbort(CLIQUE.class, params); + testParameterizationOk(params); + + // run CLIQUE on database + Clustering<SubspaceModel> result = clique.run(db); + // PairCounting is not appropriate here: overlapping clusterings! + // testFMeasure(db, result, 0.433661); + testClusterSizes(result, new int[] { 255, 409, 458, 458, 480 }); + } }
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DOCTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DOCTest.java new file mode 100644 index 00000000..00fe42bf --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DOCTest.java @@ -0,0 +1,91 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.subspace; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Test DOC on a simple test data set. + * + * On the first set, its an all-or-nothing depending on the parameters. + * + * @author Erich Schubert + * @since 0.3 + */ +public class DOCTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + /** + * Run DOC with fixed parameters and compare the result to a golden standard. + */ + @Test + public void testDOCSimple() { + Database db = makeSimpleDatabase(UNITTEST + "subspace-simple.csv", 600); + + ListParameterization params = new ListParameterization(); + params.addParameter(DOC.Parameterizer.RANDOM_ID, 0); + params.addParameter(DOC.Parameterizer.ALPHA_ID, 0.4); + params.addParameter(DOC.Parameterizer.BETA_ID, 0.85); + + // setup algorithm + DOC<DoubleVector> doc = ClassGenericsUtil.parameterizeOrAbort(DOC.class, params); + testParameterizationOk(params); + + // run DOC on database + Clustering<?> result = doc.run(db); + + testClusterSizes(result, new int[] { 200, 400 }); + testFMeasure(db, result, 1.0); + } + + /** + * Run DOC with fixed parameters and compare the result to a golden standard. + */ + @Test + public void testDOCOverlapping() { + Database db = makeSimpleDatabase(UNITTEST + "subspace-overlapping-3-4d.ascii", 850); + + // Setup algorithm + ListParameterization params = new ListParameterization(); + params.addParameter(DOC.Parameterizer.RANDOM_ID, 0); + params.addParameter(DOC.Parameterizer.ALPHA_ID, 0.4); + params.addParameter(DOC.Parameterizer.BETA_ID, 0.95); + params.addFlag(DOC.Parameterizer.HEURISTICS_ID); + params.addParameter(DOC.Parameterizer.D_ZERO_ID, 1); + + DOC<DoubleVector> doc = ClassGenericsUtil.parameterizeOrAbort(DOC.class, params); + testParameterizationOk(params); + + // run DOC on database + Clustering<?> result = doc.run(db); + testFMeasure(db, result, .54271816); + testClusterSizes(result, new int[] { 1, 20, 33, 40, 56, 104, 274, 322 }); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestDiSHResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DiSHTest.java index 7d78b18f..87b38f1d 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestDiSHResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DiSHTest.java @@ -45,8 +45,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * @author Elke Achtert * @author Katharina Rausch * @author Erich Schubert + * @since 0.3 */ -public class TestDiSHResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class DiSHTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run DiSH with fixed parameters and compare the result to a golden standard. * diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestP3C.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/P3CTest.java index cc8d2e7c..f7a88a83 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestP3C.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/P3CTest.java @@ -43,8 +43,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * But from visual inspection, this might be a true positive. * * @author Erich Schubert + * @since 0.3 */ -public class TestP3C extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class P3CTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run P3C with fixed parameters and compare the result to a golden standard. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestPROCLUSResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PROCLUSTest.java index 61c716a6..75d42b07 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestPROCLUSResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PROCLUSTest.java @@ -43,8 +43,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * @author Elke Achtert * @author Katharina Rausch * @author Erich Schubert + * @since 0.3 */ -public class TestPROCLUSResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class PROCLUSTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run PROCLUS with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestPreDeConResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PreDeConTest.java index ecd43770..6c9de70a 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestPreDeConResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PreDeConTest.java @@ -45,8 +45,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * @author Erich Schubert * @author Katharina Rausch + * @since 0.3 */ -public class TestPreDeConResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class PreDeConTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run PreDeCon with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestSUBCLUResults.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/SUBCLUTest.java index 7ae7ecaf..027f906f 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/TestSUBCLUResults.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/SUBCLUTest.java @@ -44,8 +44,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * @author Elke Achtert * @author Katharina Rausch * @author Erich Schubert + * @since 0.3 */ -public class TestSUBCLUResults extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class SUBCLUTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { /** * Run SUBCLU with fixed parameters and compare the result to a golden * standard. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/COPTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/COPTest.java new file mode 100644 index 00000000..e4d1aaf2 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/COPTest.java @@ -0,0 +1,108 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PCAFilteredAutotuningRunner; +import de.lmu.ifi.dbs.elki.math.linearalgebra.pca.RANSACCovarianceMatrixBuilder; +import de.lmu.ifi.dbs.elki.math.linearalgebra.pca.WeightedCovarianceMatrixBuilder; +import de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions.ErfcWeight; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the COP algorithm. + * + * @author Erich Schubert + * @since 0.7.1 + */ +public class COPTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testCOP() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(COP.Parameterizer.K_ID, 30); + + // setup Algorithm + COP<DoubleVector> cop = ClassGenericsUtil.parameterizeOrAbort(COP.class, params); + testParameterizationOk(params); + + OutlierResult result = cop.run(db); + + testAUC(db, "Noise", result, 0.89476666); + testSingleScore(result, 416, 0.26795866); + } + + @Test + public void testCOPRobust() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(COP.Parameterizer.K_ID, 30); + params.addParameter(COP.Parameterizer.PCARUNNER_ID, PCAFilteredAutotuningRunner.class); + params.addParameter(PCAFilteredAutotuningRunner.Parameterizer.PCA_COVARIANCE_MATRIX, WeightedCovarianceMatrixBuilder.class); + params.addParameter(WeightedCovarianceMatrixBuilder.Parameterizer.WEIGHT_ID, ErfcWeight.class); + + // setup Algorithm + COP<DoubleVector> cop = ClassGenericsUtil.parameterizeOrAbort(COP.class, params); + testParameterizationOk(params); + + OutlierResult result = cop.run(db); + + testAUC(db, "Noise", result, 0.90166666); + testSingleScore(result, 416, 0.25705955); + } + + + @Test + public void testCOPRANSAC() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(COP.Parameterizer.K_ID, 30); + params.addParameter(COP.Parameterizer.PCARUNNER_ID, PCAFilteredAutotuningRunner.class); + params.addParameter(PCAFilteredAutotuningRunner.Parameterizer.PCA_COVARIANCE_MATRIX, RANSACCovarianceMatrixBuilder.class); + params.addParameter(RANSACCovarianceMatrixBuilder.Parameterizer.ITER_ID, 25); + params.addParameter(RANSACCovarianceMatrixBuilder.Parameterizer.SEED_ID, 0); + + // setup Algorithm + COP<DoubleVector> cop = ClassGenericsUtil.parameterizeOrAbort(COP.class, params); + testParameterizationOk(params); + + OutlierResult result = cop.run(db); + + testAUC(db, "Noise", result, 0.89269999); + testSingleScore(result, 416, 0.38287932); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/DWOFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/DWOFTest.java new file mode 100644 index 00000000..24bf71ca --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/DWOFTest.java @@ -0,0 +1,60 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the DWOF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class DWOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testDWOF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(DWOF.Parameterizer.K_ID, 20); + + // setup Algorithm + DWOF<DoubleVector> cop = ClassGenericsUtil.parameterizeOrAbort(DWOF.class, params); + testParameterizationOk(params); + + OutlierResult result = cop.run(db); + + testAUC(db, "Noise", result, 0.8098666); + testSingleScore(result, 416, 6.95226128); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestGaussianModel.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianModelTest.java index 588222bd..53bb618c 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestGaussianModel.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianModelTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the GaussianModel algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestGaussianModel extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class GaussianModelTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testGaussianModel() { Database db = makeSimpleDatabase(UNITTEST + "outlier-fire.ascii", 1025); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestGaussianUniformMixture.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianUniformMixtureTest.java index 7c508b27..d42b4324 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestGaussianUniformMixture.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianUniformMixtureTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the GaussianUniformMixture algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestGaussianUniformMixture extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class GaussianUniformMixtureTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testGaussianUniformMixture() { Database db = makeSimpleDatabase(UNITTEST + "outlier-fire.ascii", 1025); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestOPTICSOF.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OPTICSOFTest.java index 6e04129e..3feb2450 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/TestOPTICSOF.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OPTICSOFTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the OPTICS-OF algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestOPTICSOF extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class OPTICSOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testOPTICSOF() { Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/SimpleCOPTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/SimpleCOPTest.java new file mode 100644 index 00000000..effcd9b7 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/SimpleCOPTest.java @@ -0,0 +1,60 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the SimpleCOP algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class SimpleCOPTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testSimpleCOP() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(SimpleCOP.Parameterizer.K_ID, 50); + + // setup Algorithm + SimpleCOP<DoubleVector> cop = ClassGenericsUtil.parameterizeOrAbort(SimpleCOP.class, params); + testParameterizationOk(params); + + OutlierResult result = cop.run(db); + + testAUC(db, "Noise", result, 0.833); + testSingleScore(result, 416, 0.); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestABOD.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/ABODTest.java index 00f93cfc..a216dade 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestABOD.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/ABODTest.java @@ -39,8 +39,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Note: we don't implement JUnit4Test, as this test is slow. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestABOD extends AbstractSimpleAlgorithmTest { +public class ABODTest extends AbstractSimpleAlgorithmTest { @Test public void testABOD() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestFastABOD.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/FastABODTest.java index 6598c70d..ede44a57 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestFastABOD.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/FastABODTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the ABOD algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestFastABOD extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class FastABODTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testFastABOD() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestLBABOD.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/LBABODTest.java index 4b5b6920..aa5dc9ba 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/TestLBABOD.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/LBABODTest.java @@ -40,8 +40,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Note: we don't implement JUnit4Test, as this test is slow. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestLBABOD extends AbstractSimpleAlgorithmTest { +public class LBABODTest extends AbstractSimpleAlgorithmTest { @Test public void testLBABOD() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/EMOutlierTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/EMOutlierTest.java new file mode 100644 index 00000000..590a7c29 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/EMOutlierTest.java @@ -0,0 +1,63 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.clustering; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.em.EM; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the EM outlier detection algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class EMOutlierTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testEMOutlierDetection() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(EM.Parameterizer.K_ID, 5); + params.addParameter(KMeans.SEED_ID, 0); + + // setup Algorithm + EMOutlier<DoubleVector> silout = ClassGenericsUtil.parameterizeOrAbort(EMOutlier.class, params); + testParameterizationOk(params); + + OutlierResult result = silout.run(db); + + testAUC(db, "Noise", result, 0.54073333); + testSingleScore(result, 416, 0.00240242); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/KMeansOutlierDetectionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/KMeansOutlierDetectionTest.java new file mode 100644 index 00000000..8a40130a --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/KMeansOutlierDetectionTest.java @@ -0,0 +1,64 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.clustering; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansHamerly; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the KMeans outlier detection algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KMeansOutlierDetectionTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testKMeansOutlierDetection() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(KMeansOutlierDetection.Parameterizer.CLUSTERING_ID, KMeansHamerly.class); + params.addParameter(KMeans.K_ID, 10); + params.addParameter(KMeans.SEED_ID, 0); + + // setup Algorithm + KMeansOutlierDetection<DoubleVector> silout = ClassGenericsUtil.parameterizeOrAbort(KMeansOutlierDetection.class, params); + testParameterizationOk(params); + + OutlierResult result = silout.run(db); + + testAUC(db, "Noise", result, 0.86166666); + testSingleScore(result, 416, 0.01025466); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/SilhouetteOutlierDetectionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/SilhouetteOutlierDetectionTest.java new file mode 100644 index 00000000..0b43e532 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/SilhouetteOutlierDetectionTest.java @@ -0,0 +1,64 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.clustering; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans; +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansHamerly; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the Silhouette outlier detection algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class SilhouetteOutlierDetectionTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testSilhouetteOutlierDetection() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-parabolic.ascii", 530); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(SilhouetteOutlierDetection.Parameterizer.CLUSTERING_ID, KMeansHamerly.class); + params.addParameter(KMeans.K_ID, 10); + params.addParameter(KMeans.SEED_ID, 0); + + // setup Algorithm + SilhouetteOutlierDetection<DoubleVector> silout = ClassGenericsUtil.parameterizeOrAbort(SilhouetteOutlierDetection.class, params); + testParameterizationOk(params); + + OutlierResult result = silout.run(db); + + testAUC(db, "Noise", result, 0.71993333); + testSingleScore(result, 416, 0.47335776); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestDBOutlierDetection.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierDetectionTest.java index 1c19366c..69ffff7d 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestDBOutlierDetection.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierDetectionTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the DBOutlierDetection algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestDBOutlierDetection extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class DBOutlierDetectionTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testDBOutlierDetection() { Database db = makeSimpleDatabase(UNITTEST + "outlier-fire.ascii", 1025); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestDBOutlierScore.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierScoreTest.java index 47fd73bf..cb70cabe 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestDBOutlierScore.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierScoreTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the DBOutlierScore algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestDBOutlierScore extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class DBOutlierScoreTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testDBOutlierScore() { Database db = makeSimpleDatabase(UNITTEST + "outlier-fire.ascii", 1025); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/HilOutTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/HilOutTest.java new file mode 100644 index 00000000..e1cd3a53 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/HilOutTest.java @@ -0,0 +1,62 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.distance; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the KNNWeightOutlier algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class HilOutTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testHilOut() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(HilOut.Parameterizer.K_ID, 4); + params.addParameter(HilOut.Parameterizer.N_ID, 200); + + // setup Algorithm + HilOut<DoubleVector> hilout = ClassGenericsUtil.parameterizeOrAbort(HilOut.class, params); + testParameterizationOk(params); + + // run KNNWeightOutlier on database + OutlierResult result = hilout.run(db); + + testAUC(db, "Noise", result, 0.985398148); + testSingleScore(result, 945, 1.70927657); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestKNNOutlier.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNOutlierTest.java index b7ac1bd8..2720ff28 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestKNNOutlier.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNOutlierTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the KNNOutlier algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestKNNOutlier extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KNNOutlierTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testKNNOutlier() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestKNNWeightOutlier.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNWeightOutlierTest.java index 73f5db45..cb72b9d7 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestKNNWeightOutlier.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNWeightOutlierTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the KNNWeightOutlier algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestKNNWeightOutlier extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class KNNWeightOutlierTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testKNNWeightOutlier() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestLocalIsolationCoefficient.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/LocalIsolationCoefficientTest.java index c49beb5f..f781ed28 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestLocalIsolationCoefficient.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/LocalIsolationCoefficientTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the LocalIsolationCoefficient algorithm. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestLocalIsolationCoefficient extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class LocalIsolationCoefficientTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testLocalIsolationCoefficient() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ODINTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ODINTest.java new file mode 100644 index 00000000..1186bcac --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ODINTest.java @@ -0,0 +1,61 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.distance; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the ODIN algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class ODINTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testODIN() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ODIN.Parameterizer.K_ID, 10); + + // setup Algorithm + ODIN<DoubleVector> odin = ClassGenericsUtil.parameterizeOrAbort(ODIN.class, params); + testParameterizationOk(params); + + // run KNNOutlier on database + OutlierResult result = odin.run(db); + + testSingleScore(result, 945, 0.7); + testAUC(db, "Noise", result, 0.9142037037); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ReferenceBasedOutlierDetectionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ReferenceBasedOutlierDetectionTest.java new file mode 100644 index 00000000..d9b96d09 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ReferenceBasedOutlierDetectionTest.java @@ -0,0 +1,151 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.distance; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; +import de.lmu.ifi.dbs.elki.utilities.referencepoints.AxisBasedReferencePoints; +import de.lmu.ifi.dbs.elki.utilities.referencepoints.GridBasedReferencePoints; +import de.lmu.ifi.dbs.elki.utilities.referencepoints.RandomGeneratedReferencePoints; +import de.lmu.ifi.dbs.elki.utilities.referencepoints.RandomSampleReferencePoints; +import de.lmu.ifi.dbs.elki.utilities.referencepoints.StarBasedReferencePoints; + +/** + * Tests the ReferenceBasedOutlierDetection algorithm. + * + * @author Lucia Cichella + * @author Erich Schubert + * @since 0.4.0 + */ +public class ReferenceBasedOutlierDetectionTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testReferenceBasedOutlierDetection() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); + params.addParameter(GridBasedReferencePoints.Parameterizer.GRID_ID, 3); + + // setup Algorithm + ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); + testParameterizationOk(params); + + // run ReferenceBasedOutlierDetection on database + OutlierResult result = referenceBasedOutlierDetection.run(db); + + testAUC(db, "Noise", result, 0.9693703703703); + testSingleScore(result, 945, 0.933574455); + } + + @Test + public void testReferenceBasedOutlierDetectionStar() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.REFP_ID, StarBasedReferencePoints.class); + + // setup Algorithm + ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); + testParameterizationOk(params); + + // run ReferenceBasedOutlierDetection on database + OutlierResult result = referenceBasedOutlierDetection.run(db); + + testAUC(db, "Noise", result, 0.910722222); + testSingleScore(result, 945, 0.920950222); + } + + @Test + public void testReferenceBasedOutlierDetectionAxis() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.REFP_ID, AxisBasedReferencePoints.class); + + // setup Algorithm + ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); + testParameterizationOk(params); + + // run ReferenceBasedOutlierDetection on database + OutlierResult result = referenceBasedOutlierDetection.run(db); + + testAUC(db, "Noise", result, 0.8110555); + testSingleScore(result, 945, 0.9523053); + } + + @Test + public void testReferenceBasedOutlierDetectionGenerated() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.REFP_ID, RandomGeneratedReferencePoints.class); + params.addParameter(RandomGeneratedReferencePoints.Parameterizer.N_ID, 15); + params.addParameter(RandomGeneratedReferencePoints.Parameterizer.RANDOM_ID, 0); + + // setup Algorithm + ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); + testParameterizationOk(params); + + // run ReferenceBasedOutlierDetection on database + OutlierResult result = referenceBasedOutlierDetection.run(db); + + testAUC(db, "Noise", result, 0.817407407); + testSingleScore(result, 945, 0.911353060); + } + + @Test + public void testReferenceBasedOutlierDetectionSample() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); + params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.REFP_ID, RandomSampleReferencePoints.class); + params.addParameter(RandomSampleReferencePoints.Parameterizer.N_ID, 15); + params.addParameter(RandomSampleReferencePoints.Parameterizer.RANDOM_ID, 0); + + // setup Algorithm + ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); + testParameterizationOk(params); + + // run ReferenceBasedOutlierDetection on database + OutlierResult result = referenceBasedOutlierDetection.run(db); + + testAUC(db, "Noise", result, 0.848472222); + testSingleScore(result, 945, 0.894389944); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestReferenceBasedOutlierDetection.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestReferenceBasedOutlierDetection.java deleted file mode 100644 index de0991d0..00000000 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/TestReferenceBasedOutlierDetection.java +++ /dev/null @@ -1,61 +0,0 @@ -package de.lmu.ifi.dbs.elki.algorithm.outlier.distance; - -/* - This file is part of ELKI: - Environment for Developing KDD-Applications Supported by Index-Structures - - Copyright (C) 2015 - Ludwig-Maximilians-Universität München - Lehr- und Forschungseinheit für Datenbanksysteme - ELKI Development Team - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Affero General Public License for more details. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -import org.junit.Test; - -import de.lmu.ifi.dbs.elki.JUnit4Test; -import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; -import de.lmu.ifi.dbs.elki.database.Database; -import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; -import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; -import de.lmu.ifi.dbs.elki.utilities.referencepoints.GridBasedReferencePoints; - -/** - * Tests the ReferenceBasedOutlierDetection algorithm. - * - * @author Lucia Cichella - */ -public class TestReferenceBasedOutlierDetection extends AbstractSimpleAlgorithmTest implements JUnit4Test { - @Test - public void testReferenceBasedOutlierDetection() { - Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); - - // Parameterization - ListParameterization params = new ListParameterization(); - params.addParameter(ReferenceBasedOutlierDetection.Parameterizer.K_ID, 11); - params.addParameter(GridBasedReferencePoints.Parameterizer.GRID_ID, 3); - - // setup Algorithm - ReferenceBasedOutlierDetection referenceBasedOutlierDetection = ClassGenericsUtil.parameterizeOrAbort(ReferenceBasedOutlierDetection.class, params); - testParameterizationOk(params); - - // run ReferenceBasedOutlierDetection on database - OutlierResult result = referenceBasedOutlierDetection.run(db); - - testAUC(db, "Noise", result, 0.9418148148); - testSingleScore(result, 945, 0.87173403699); - } -}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/TestParallelKNNOutlier.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNOutlierTest.java index 3dfe5664..455f5730 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/TestParallelKNNOutlier.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNOutlierTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the KNNOutlier algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestParallelKNNOutlier extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class ParallelKNNOutlierTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testKNNOutlier() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/TestParallelKNNWeightOutlier.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNWeightOutlierTest.java index 7391bfed..1c298214 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/TestParallelKNNWeightOutlier.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNWeightOutlierTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the KNNWeightOutlier algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestParallelKNNWeightOutlier extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class ParallelKNNWeightOutlierTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testKNNWeightOutlier() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/ALOCITest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/ALOCITest.java new file mode 100644 index 00000000..378f8477 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/ALOCITest.java @@ -0,0 +1,62 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the ALOCI algorithm. + * + * @author Lucia Cichella + * @since 0.4.0 + */ +public class ALOCITest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testLOCI() { + Database db = makeSimpleDatabase(UNITTEST + "3clusters-and-noise-2d.csv", 330); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(ALOCI.Parameterizer.SEED_ID, 0); + params.addParameter(ALOCI.Parameterizer.GRIDS_ID, 3); + + // setup Algorithm + ALOCI<DoubleVector> aloci = ClassGenericsUtil.parameterizeOrAbort(ALOCI.class, params); + testParameterizationOk(params); + + // run LOCI on database + OutlierResult result = aloci.run(db); + + testAUC(db, "Noise", result, 0.77011111); + testSingleScore(result, 146, 1.1242238186577); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/COFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/COFTest.java new file mode 100644 index 00000000..eac2f982 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/COFTest.java @@ -0,0 +1,61 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the COF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class COFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testCOF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(COF.Parameterizer.K_ID, 10); + + // setup Algorithm + COF<DoubleVector> cof = ClassGenericsUtil.parameterizeOrAbort(COF.class, params); + testParameterizationOk(params); + + // run COF on database + OutlierResult result = cof.run(db); + + testSingleScore(result, 1293, 1.415457); + testAUC(db, "Noise", result, 0.8696806); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/FlexibleLOFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/FlexibleLOFTest.java new file mode 100644 index 00000000..c4165a00 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/FlexibleLOFTest.java @@ -0,0 +1,61 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the LOF algorithm. + * + * @author Lucia Cichella + * @since 0.4.0 + */ +public class FlexibleLOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testFlexibleLOF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(FlexibleLOF.Parameterizer.KREF_ID, 10); + + // setup Algorithm + FlexibleLOF<DoubleVector> flof = ClassGenericsUtil.parameterizeOrAbort(FlexibleLOF.class, params); + testParameterizationOk(params); + + // run LOF on database + OutlierResult result = flof.run(db); + + testSingleScore(result, 1293, 1.1945314199156365); + testAUC(db, "Noise", result, 0.8921680672268908); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestINFLO.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/INFLOTest.java index 866effa6..d6c01b2a 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestINFLO.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/INFLOTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the INFLO algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestINFLO extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class INFLOTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testINFLO() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/KDEOSTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/KDEOSTest.java new file mode 100644 index 00000000..096e3aa6 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/KDEOSTest.java @@ -0,0 +1,65 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.EpanechnikovKernelDensityFunction; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the KDEOS algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class KDEOSTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testKDEOS() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(KDEOS.Parameterizer.KERNEL_ID, EpanechnikovKernelDensityFunction.class); + params.addParameter(KDEOS.Parameterizer.KMIN_ID, 5); + params.addParameter(KDEOS.Parameterizer.KMAX_ID, 20); + params.addParameter(KDEOS.Parameterizer.KERNEL_SCALE_ID, 1.0); + + // setup Algorithm + KDEOS<DoubleVector> kdeos = ClassGenericsUtil.parameterizeOrAbort(KDEOS.class, params); + testParameterizationOk(params); + + // run LOF on database + OutlierResult result = kdeos.run(db); + + testAUC(db, "Noise", result, 0.7983529411764); + testSingleScore(result, 1293, 0.8788346606616); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDFTest.java new file mode 100644 index 00000000..c724598b --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDFTest.java @@ -0,0 +1,62 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the LDF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class LDFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testLDF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(LDF.Parameterizer.K_ID, 10); + params.addParameter(LDF.Parameterizer.H_ID, 1); + + // setup Algorithm + LDF<DoubleVector> ldf = ClassGenericsUtil.parameterizeOrAbort(LDF.class, params); + testParameterizationOk(params); + + // run LDF on database + OutlierResult result = ldf.run(db); + + testSingleScore(result, 1293, 3.158819); + testAUC(db, "Noise", result, 0.9127619); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLDOF.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDOFTest.java index c728e38e..8eb45790 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLDOF.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDOFTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the LDOF algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestLDOF extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class LDOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testLDOF() { Database db = makeSimpleDatabase(UNITTEST + "outlier-fire.ascii", 1025); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLOCI.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOCITest.java index a2934701..2438f6cb 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLOCI.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOCITest.java @@ -35,17 +35,18 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet /** * Tests the LOCI algorithm. - * + * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestLOCI extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class LOCITest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testLOCI() { Database db = makeSimpleDatabase(UNITTEST + "3clusters-and-noise-2d.csv", 330); // Parameterization ListParameterization params = new ListParameterization(); - params.addParameter(LOCI.RMAX_ID, 0.5); + params.addParameter(LOCI.Parameterizer.RMAX_ID, 0.5); // setup Algorithm LOCI<DoubleVector> loci = ClassGenericsUtil.parameterizeOrAbort(LOCI.class, params); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLOF.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOFTest.java index d54d760e..33ab6d2d 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLOF.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOFTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the LOF algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestLOF extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class LOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testLOF() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLoOP.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LoOPTest.java index 60dddb5d..110c02bd 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestLoOP.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LoOPTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the LoOP algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestLoOP extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class LoOPTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testLoOP() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestOnlineLOF.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/OnlineLOFTest.java index f5fda922..947d6fcf 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestOnlineLOF.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/OnlineLOFTest.java @@ -63,9 +63,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * BUG: This currently does not appear to work correctly! * * @author Elke Achtert + * @since 0.4.0 */ @Ignore -public class TestOnlineLOF implements JUnit4Test { +public class OnlineLOFTest implements JUnit4Test { // the following values depend on the data set used! static String dataset = "data/testdata/unittests/3clusters-and-noise-2d.csv"; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimpleKernelDensityLOFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimpleKernelDensityLOFTest.java new file mode 100644 index 00000000..19223930 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimpleKernelDensityLOFTest.java @@ -0,0 +1,63 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.BiweightKernelDensityFunction; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Tests the SimpleKernelDensityLOF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class SimpleKernelDensityLOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testLDF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(LOF.Parameterizer.K_ID, 20); + params.addParameter(SimpleKernelDensityLOF.Parameterizer.KERNEL_ID, BiweightKernelDensityFunction.class); + + // setup Algorithm + SimpleKernelDensityLOF<DoubleVector> klof = ClassGenericsUtil.parameterizeOrAbort(SimpleKernelDensityLOF.class, params); + testParameterizationOk(params); + + // run LDF on database + OutlierResult result = klof.run(db); + + testAUC(db, "Noise", result, 0.87192156); + testSingleScore(result, 1293, 12.271188); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestSimplifiedLOF.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimplifiedLOFTest.java index 3ef40851..851bb5d6 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestSimplifiedLOF.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimplifiedLOFTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the LOF algorithm. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestSimplifiedLOF extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class SimplifiedLOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testSimplifiedLOF() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestVarianceOfVolume.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/VarianceOfVolumeTest.java index 266e9f35..3cbe5b78 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/TestVarianceOfVolume.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/VarianceOfVolumeTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the Variance of Volume algorithm. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestVarianceOfVolume extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class VarianceOfVolumeTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testVOV() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); @@ -54,7 +55,7 @@ public class TestVarianceOfVolume extends AbstractSimpleAlgorithmTest implements // run LOF on database OutlierResult result = lof.run(db); - testSingleScore(result, 1293, 848349.0186); - testAUC(db, "Noise", result, 0.936448179271); + testSingleScore(result, 1293, 2.0733100852601836e13); + testAUC(db, "Noise", result, 0.9306946778); } }
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelLOFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelLOFTest.java new file mode 100644 index 00000000..7dcd568a --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelLOFTest.java @@ -0,0 +1,62 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof.parallel; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.outlier.lof.LOF; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Regression tests the ParallelLOF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class ParallelLOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testParallelLOF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(LOF.Parameterizer.K_ID, 10); + + // setup Algorithm + ParallelLOF<DoubleVector> lof = ClassGenericsUtil.parameterizeOrAbort(ParallelLOF.class, params); + testParameterizationOk(params); + + // run ParallelLOF on database + OutlierResult result = lof.run(db); + + testSingleScore(result, 1293, 1.1945314199156365); + testAUC(db, "Noise", result, 0.8921680672268908); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelSimplifiedLOFTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelSimplifiedLOFTest.java new file mode 100644 index 00000000..5bea31e9 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelSimplifiedLOFTest.java @@ -0,0 +1,62 @@ +package de.lmu.ifi.dbs.elki.algorithm.outlier.lof.parallel; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.algorithm.AbstractSimpleAlgorithmTest; +import de.lmu.ifi.dbs.elki.algorithm.outlier.lof.LOF; +import de.lmu.ifi.dbs.elki.data.DoubleVector; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Regression tests the parallel SimplifiedLOF algorithm. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class ParallelSimplifiedLOFTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { + @Test + public void testParallelSimplifiedLOF() { + Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); + + // Parameterization + ListParameterization params = new ListParameterization(); + params.addParameter(LOF.Parameterizer.K_ID, 10); + + // setup Algorithm + ParallelSimplifiedLOF<DoubleVector> lof = ClassGenericsUtil.parameterizeOrAbort(ParallelSimplifiedLOF.class, params); + testParameterizationOk(params); + + // run LOF on database + OutlierResult result = lof.run(db); + + testAUC(db, "Noise", result, 0.8892549019); + testSingleScore(result, 1293, 1.3025894); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/TestFeatureBagging.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/FeatureBaggingTest.java index 91f20b28..b5fd84be 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/TestFeatureBagging.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/FeatureBaggingTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the Feature Bagging algorithm. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestFeatureBagging extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class FeatureBaggingTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testFeatureBaggingSum() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/TestHiCS.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/HiCSTest.java index bb10269d..cfa904dc 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/TestHiCS.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/HiCSTest.java @@ -40,8 +40,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the HiCS algorithm. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestHiCS extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class HiCSTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testHiCSKS() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestAggarwalYuEvolutionary.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuEvolutionaryTest.java index 67168d3f..2961d6e7 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestAggarwalYuEvolutionary.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuEvolutionaryTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the AggarwalYuEvolutionary algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestAggarwalYuEvolutionary extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class AggarwalYuEvolutionaryTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testAggarwalYuEvolutionary() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestAggarwalYuNaive.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuNaiveTest.java index 8ecdbe26..6e3eeb5d 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestAggarwalYuNaive.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuNaiveTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the AggarwalYuNaive algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestAggarwalYuNaive extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class AggarwalYuNaiveTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testAggarwalYuNaive() { Database db = makeSimpleDatabase(UNITTEST + "outlier-3d-3clusters.ascii", 960); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestSOD.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/SODTest.java index d55f3f41..d7fee573 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/TestSOD.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/SODTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Tests the SOD algorithm. * * @author Lucia Cichella + * @since 0.4.0 */ -public class TestSOD extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class SODTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test public void testSOD() { Database db = makeSimpleDatabase(UNITTEST + "outlier-axis-subspaces-6d.ascii", 1345); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/data/spatial/TestPolygon.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/data/spatial/PolygonTest.java index 59dfa986..61040c8e 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/data/spatial/TestPolygon.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/data/spatial/PolygonTest.java @@ -33,7 +33,13 @@ import org.junit.Test; import de.lmu.ifi.dbs.elki.JUnit4Test; import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; -public class TestPolygon implements JUnit4Test { +/** + * Test the polygon class. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class PolygonTest implements JUnit4Test { @Test public void testPolygonContainment() { final Polygon p1, p2, p3; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/database/TestRelationSorting.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/database/RelationSortingTest.java index c2a356e3..2735f6b1 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/database/TestRelationSorting.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/database/RelationSortingTest.java @@ -47,9 +47,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * the database and ID layers. * * @author Erich Schubert + * @since 0.5.5 * */ -public class TestRelationSorting implements JUnit4Test { +public class RelationSortingTest implements JUnit4Test { public static final String filename = "data/testdata/unittests/hierarchical-3d2d1d.csv"; @Test diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/database/TestSortingDuplicates.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/database/SortingDuplicatesTest.java index ab4d69b0..62ddbaf8 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/database/TestSortingDuplicates.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/database/SortingDuplicatesTest.java @@ -33,8 +33,9 @@ import de.lmu.ifi.dbs.elki.database.ids.ModifiableDoubleDBIDList; * Test a corner case when sorting: duplicate keys. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestSortingDuplicates implements JUnit4Test { +public class SortingDuplicatesTest implements JUnit4Test { @Test(timeout = 100) public void testDuplicateKeys() { // We need an ide, but no real data. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/datasource/parser/TestTermFrequencyParser.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/datasource/parser/TermFrequencyParserTest.java index 02b227ce..59d53f28 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/datasource/parser/TestTermFrequencyParser.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/datasource/parser/TermFrequencyParserTest.java @@ -52,8 +52,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * TODO: maybe also run an example algorithm? * * @author Erich Schubert + * @since 0.6.0 */ -public class TestTermFrequencyParser implements JUnit4Test { +public class TermFrequencyParserTest implements JUnit4Test { /** Test data set to use. */ public static String DBLP_DATA = "data/testdata/parsing/termfreq-dblp.ascii.gz"; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/datasource/parser/TestTokenizer.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/datasource/parser/TokenizerTest.java index c9e66400..d1e2e31e 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/datasource/parser/TestTokenizer.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/datasource/parser/TokenizerTest.java @@ -40,8 +40,9 @@ import de.lmu.ifi.dbs.elki.utilities.io.Tokenizer; * TODO: add more test cases, refactor into input, expected-output pattern. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestTokenizer implements JUnit4Test { +public class TokenizerTest implements JUnit4Test { Tokenizer t = new Tokenizer(Pattern.compile("\\s"), "\"'"); @Test diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SpatialPrimitiveDistanceFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SpatialPrimitiveDistanceFunctionTest.java index 0eb7f36f..19091cd9 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SpatialPrimitiveDistanceFunctionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SpatialPrimitiveDistanceFunctionTest.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * random objects. * * @author Erich Schubert + * @since 0.5.0 * */ public class SpatialPrimitiveDistanceFunctionTest implements JUnit4Test { diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestAbsolutePearsonCorrelationDistanceFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsolutePearsonCorrelationDistanceFunctionTest.java index 50d2e213..dfd01522 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestAbsolutePearsonCorrelationDistanceFunctionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsolutePearsonCorrelationDistanceFunctionTest.java @@ -33,13 +33,14 @@ import de.lmu.ifi.dbs.elki.data.DoubleVector; * Unit test for Absolute Pearson correlation distance. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestAbsolutePearsonCorrelationDistanceFunctionTest implements JUnit4Test { +public class AbsolutePearsonCorrelationDistanceFunctionTest implements JUnit4Test { /** Test set */ - final static DoubleVector[] TESTS = TestPearsonCorrelationDistanceFunctionTest.TESTS; + final static DoubleVector[] TESTS = PearsonCorrelationDistanceFunctionTest.TESTS; /** Note, these are not yet adjusted */ - final static double[][] SCORES = TestPearsonCorrelationDistanceFunctionTest.SCORES; + final static double[][] SCORES = PearsonCorrelationDistanceFunctionTest.SCORES; @Test public void testAbsolutePearson() { diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestAbsoluteUncenteredCorrelationDistanceFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsoluteUncenteredCorrelationDistanceFunctionTest.java index ade6e19a..f8855e67 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestAbsoluteUncenteredCorrelationDistanceFunctionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsoluteUncenteredCorrelationDistanceFunctionTest.java @@ -33,13 +33,14 @@ import de.lmu.ifi.dbs.elki.data.DoubleVector; * Unit test for Absolute Pearson correlation distance. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestAbsoluteUncenteredCorrelationDistanceFunctionTest implements JUnit4Test { +public class AbsoluteUncenteredCorrelationDistanceFunctionTest implements JUnit4Test { /** Inherited test data */ - final static DoubleVector[] TESTS = TestUncenteredCorrelationDistanceFunctionTest.TESTS; + final static DoubleVector[] TESTS = UncenteredCorrelationDistanceFunctionTest.TESTS; /** Note, these are not yet adjusted */ - final static double[][] SCORES = TestUncenteredCorrelationDistanceFunctionTest.SCORES; + final static double[][] SCORES = UncenteredCorrelationDistanceFunctionTest.SCORES; @Test public void testAbsoluteUncenteredCorrelation() { diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestPearsonCorrelationDistanceFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/PearsonCorrelationDistanceFunctionTest.java index eb80b8f8..bbe50452 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestPearsonCorrelationDistanceFunctionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/PearsonCorrelationDistanceFunctionTest.java @@ -33,8 +33,9 @@ import de.lmu.ifi.dbs.elki.data.DoubleVector; * Unit test for Pearson correlation distance. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestPearsonCorrelationDistanceFunctionTest implements JUnit4Test { +public class PearsonCorrelationDistanceFunctionTest implements JUnit4Test { /** * Some test series. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestSquaredPearsonCorrelationDistanceFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredPearsonCorrelationDistanceFunctionTest.java index b541ec0f..5896a4e9 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestSquaredPearsonCorrelationDistanceFunctionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredPearsonCorrelationDistanceFunctionTest.java @@ -33,13 +33,14 @@ import de.lmu.ifi.dbs.elki.data.DoubleVector; * Unit test for squared Pearson correlation distance. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestSquaredPearsonCorrelationDistanceFunctionTest implements JUnit4Test { +public class SquaredPearsonCorrelationDistanceFunctionTest implements JUnit4Test { /** Test set */ - final static DoubleVector[] TESTS = TestPearsonCorrelationDistanceFunctionTest.TESTS; + final static DoubleVector[] TESTS = PearsonCorrelationDistanceFunctionTest.TESTS; /** Note, these are not yet adjusted */ - final static double[][] SCORES = TestPearsonCorrelationDistanceFunctionTest.SCORES; + final static double[][] SCORES = PearsonCorrelationDistanceFunctionTest.SCORES; @Test public void testSquaredPearson() { diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestSquaredUncenteredCorrelationDistanceFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredUncenteredCorrelationDistanceFunctionTest.java index 85b0d934..298616ed 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestSquaredUncenteredCorrelationDistanceFunctionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredUncenteredCorrelationDistanceFunctionTest.java @@ -33,13 +33,14 @@ import de.lmu.ifi.dbs.elki.data.DoubleVector; * Unit test for Squared Pearson correlation distance. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestSquaredUncenteredCorrelationDistanceFunctionTest implements JUnit4Test { +public class SquaredUncenteredCorrelationDistanceFunctionTest implements JUnit4Test { /** Inherited test data */ - final static DoubleVector[] TESTS = TestUncenteredCorrelationDistanceFunctionTest.TESTS; + final static DoubleVector[] TESTS = UncenteredCorrelationDistanceFunctionTest.TESTS; /** Note, these are not yet adjusted */ - final static double[][] SCORES = TestUncenteredCorrelationDistanceFunctionTest.SCORES; + final static double[][] SCORES = UncenteredCorrelationDistanceFunctionTest.SCORES; @Test public void testSquaredUncenteredCorrelation() { diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestUncenteredCorrelationDistanceFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/UncenteredCorrelationDistanceFunctionTest.java index 2f03eb81..e580dbda 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/TestUncenteredCorrelationDistanceFunctionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/UncenteredCorrelationDistanceFunctionTest.java @@ -33,10 +33,11 @@ import de.lmu.ifi.dbs.elki.data.DoubleVector; * Unit test for Absolute Pearson correlation distance. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestUncenteredCorrelationDistanceFunctionTest implements JUnit4Test { +public class UncenteredCorrelationDistanceFunctionTest implements JUnit4Test { /** Inherited test data */ - final static DoubleVector[] TESTS = TestPearsonCorrelationDistanceFunctionTest.TESTS; + final static DoubleVector[] TESTS = PearsonCorrelationDistanceFunctionTest.TESTS; /** Dissimilarities */ static final double C1 = 1.3636363636363638, C2 = 0.23636363636363633, diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/TestFileBasedDoubleDistanceFunction.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/FileBasedDoubleDistanceFunctionTest.java index 8091727c..0bde5412 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/TestFileBasedDoubleDistanceFunction.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/FileBasedDoubleDistanceFunctionTest.java @@ -43,8 +43,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Unit test for external distances. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestFileBasedDoubleDistanceFunction extends AbstractSimpleAlgorithmTest implements JUnit4Test { +public class FileBasedDoubleDistanceFunctionTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { final static String FILENAME = "data/testdata/unittests/distance/AsciiDistanceMatrix.ascii"; @Test diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/LevenshteinDistanceFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/LevenshteinDistanceFunctionTest.java index dff58823..7342a30c 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/LevenshteinDistanceFunctionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/LevenshteinDistanceFunctionTest.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Unit test for Levenshtein distance. * * @author Erich Schubert + * @since 0.4.0 */ public class LevenshteinDistanceFunctionTest implements JUnit4Test { /** diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/NormalizedLevenshteinDistanceFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/NormalizedLevenshteinDistanceFunctionTest.java index fa99837e..dee74ff2 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/NormalizedLevenshteinDistanceFunctionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/NormalizedLevenshteinDistanceFunctionTest.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Unit test for Levenshtein distance. * * @author Erich Schubert + * @since 0.4.0 */ public class NormalizedLevenshteinDistanceFunctionTest implements JUnit4Test { /** diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DTWDistanceFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DTWDistanceFunctionTest.java index 4855c1bf..d4edcc25 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DTWDistanceFunctionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DTWDistanceFunctionTest.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.data.DoubleVector; * Unit test for dynamic time warping distance. * * @author Erich Schubert + * @since 0.7.0 */ public class DTWDistanceFunctionTest implements JUnit4Test { /** diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DerivativeDTWDistanceFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DerivativeDTWDistanceFunctionTest.java index 8d6e9361..4f61136b 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DerivativeDTWDistanceFunctionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DerivativeDTWDistanceFunctionTest.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.data.DoubleVector; * Unit test for dynamic time warping distance. * * @author Erich Schubert + * @since 0.7.0 */ public class DerivativeDTWDistanceFunctionTest implements JUnit4Test { /** diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/LinearKernelFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/LinearKernelFunctionTest.java new file mode 100644 index 00000000..b7e10b6d --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/LinearKernelFunctionTest.java @@ -0,0 +1,55 @@ +package de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.data.DoubleVector; + +/** + * Unit test for Kernel implementation. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class LinearKernelFunctionTest implements JUnit4Test { + @Test + public void testToyExamples() { + DoubleVector v1 = new DoubleVector(new double[] { 1, 0, 0 }); + DoubleVector v2 = new DoubleVector(new double[] { 0, 1, 0 }); + DoubleVector v3 = new DoubleVector(new double[] { 1, 1, 1 }); + DoubleVector v4 = new DoubleVector(new double[] { .1, .2, .3 }); + + LinearKernelFunction kernel = LinearKernelFunction.STATIC; + assertEquals("Linear kernel not correct.", 0., kernel.similarity(v1, v2), 0.); + assertEquals("Linear kernel not correct.", 1., kernel.similarity(v1, v3), 0.); + assertEquals("Linear kernel not correct.", .1, kernel.similarity(v1, v4), 0.); + assertEquals("Linear kernel not correct.", 1., kernel.similarity(v2, v3), 0.); + assertEquals("Linear kernel not correct.", .2, kernel.similarity(v2, v4), 0.); + assertEquals("Linear kernel not correct.", .6, kernel.similarity(v3, v4), 1e-13); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/PolynomialKernelFunctionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/PolynomialKernelFunctionTest.java new file mode 100644 index 00000000..fd1e0d39 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/PolynomialKernelFunctionTest.java @@ -0,0 +1,71 @@ +package de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; +import de.lmu.ifi.dbs.elki.data.DoubleVector; + +/** + * Unit test for Kernel implementation. + * + * @author Erich Schubert + * @since 0.7.1 + */ +public class PolynomialKernelFunctionTest implements JUnit4Test { + @Test + public void testToyExamplesPoly2() { + DoubleVector v1 = new DoubleVector(new double[] { 1, 0, 0 }); + DoubleVector v2 = new DoubleVector(new double[] { 0, 1, 0 }); + DoubleVector v3 = new DoubleVector(new double[] { 1, 1, 1 }); + DoubleVector v4 = new DoubleVector(new double[] { .1, .2, .3 }); + + PolynomialKernelFunction kernel = new PolynomialKernelFunction(2); + assertEquals("Linear kernel not correct.", 0., kernel.similarity(v1, v2), 0.); + assertEquals("Linear kernel not correct.", 1., kernel.similarity(v1, v3), 0.); + assertEquals("Linear kernel not correct.", .01, kernel.similarity(v1, v4), 1e-13); + assertEquals("Linear kernel not correct.", 1., kernel.similarity(v2, v3), 0.); + assertEquals("Linear kernel not correct.", .04, kernel.similarity(v2, v4), 1e-13); + assertEquals("Linear kernel not correct.", .36, kernel.similarity(v3, v4), 1e-13); + } + + @Test + public void testToyExamplesPoly3() { + DoubleVector v1 = new DoubleVector(new double[] { 1, 0, 0 }); + DoubleVector v2 = new DoubleVector(new double[] { 0, 1, 0 }); + DoubleVector v3 = new DoubleVector(new double[] { 1, 1, 1 }); + DoubleVector v4 = new DoubleVector(new double[] { .1, .2, .3 }); + + PolynomialKernelFunction kernel = new PolynomialKernelFunction(3); + assertEquals("Linear kernel not correct.", 0., kernel.similarity(v1, v2), 0.); + assertEquals("Linear kernel not correct.", 1., kernel.similarity(v1, v3), 0.); + assertEquals("Linear kernel not correct.", .001, kernel.similarity(v1, v4), 1e-13); + assertEquals("Linear kernel not correct.", 1., kernel.similarity(v2, v3), 0.); + assertEquals("Linear kernel not correct.", .008, kernel.similarity(v2, v4), 1e-13); + assertEquals("Linear kernel not correct.", .216, kernel.similarity(v3, v4), 1e-13); + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/paircounting/TestClusterContingencyTable.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/paircounting/ClusterContingencyTableTest.java index 7e2fd526..6a594bd1 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/paircounting/TestClusterContingencyTable.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/paircounting/ClusterContingencyTableTest.java @@ -49,8 +49,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * data clusterings. * * @author Erich Schubert + * @since 0.2 */ -public class TestClusterContingencyTable implements JUnit4Test { +public class ClusterContingencyTableTest implements JUnit4Test { // the following values depend on the data set used! String dataset = "data/testdata/unittests/hierarchical-3d2d1d.csv"; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/TestAveragePrecisionEvaluation.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/AveragePrecisionEvaluationTest.java index c635d790..a92cea06 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/TestAveragePrecisionEvaluation.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/AveragePrecisionEvaluationTest.java @@ -36,8 +36,9 @@ import de.lmu.ifi.dbs.elki.database.ids.ModifiableDoubleDBIDList; * Test to validate ROC curve computation. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestAveragePrecisionEvaluation implements JUnit4Test { +public class AveragePrecisionEvaluationTest implements JUnit4Test { /** * Test Average Precision score computation. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/TestMaximumF1Evaluation.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/MaximumF1EvaluationTest.java index 3e6757fe..9666d7c2 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/TestMaximumF1Evaluation.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/MaximumF1EvaluationTest.java @@ -36,8 +36,9 @@ import de.lmu.ifi.dbs.elki.database.ids.ModifiableDoubleDBIDList; * Validate evaluation based on F1 scores. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestMaximumF1Evaluation implements JUnit4Test { +public class MaximumF1EvaluationTest implements JUnit4Test { /** * Test maximum F1 score computation */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/TestPrecisionAtKEvaluation.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/PrecisionAtKEvaluationTest.java index ca973196..2aac1f30 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/TestPrecisionAtKEvaluation.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/PrecisionAtKEvaluationTest.java @@ -36,8 +36,9 @@ import de.lmu.ifi.dbs.elki.database.ids.ModifiableDoubleDBIDList; * Test precision@k evaluation. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestPrecisionAtKEvaluation implements JUnit4Test { +public class PrecisionAtKEvaluationTest implements JUnit4Test { /** * Test Precision@k score computation. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/TestROCEvaluation.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/ROCEvaluationTest.java index 34ab3b3a..31113d70 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/TestROCEvaluation.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/evaluation/scores/ROCEvaluationTest.java @@ -39,8 +39,9 @@ import de.lmu.ifi.dbs.elki.math.geometry.XYCurve; * Test to validate ROC curve computation. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestROCEvaluation implements JUnit4Test { +public class ROCEvaluationTest implements JUnit4Test { /** * Test ROC curve generation, including curve simplification */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/AbstractTestIndexStructures.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/AbstractIndexStructureTest.java index c3dbf7e6..abe7aaf2 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/AbstractTestIndexStructures.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/AbstractIndexStructureTest.java @@ -52,8 +52,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * results. * * @author Erich Schubert + * @since 0.2 */ -public abstract class AbstractTestIndexStructures implements JUnit4Test { +public abstract class AbstractIndexStructureTest implements JUnit4Test { // the following values depend on the data set used! String dataset = "data/testdata/unittests/hierarchical-3d2d1d.csv"; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/TestLinearScanReference.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/LinearScanReferenceTest.java index 82640612..6e2e0abb 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/TestLinearScanReference.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/LinearScanReferenceTest.java @@ -33,8 +33,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * This unit test verifies that the linear scan produces the reference result. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestLinearScanReference extends AbstractTestIndexStructures { +public class LinearScanReferenceTest extends AbstractIndexStructureTest { /** * Test exact query, also to validate the test is correct. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/idistance/TestIDistance.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/idistance/IDistanceTest.java index 7280af84..de406ef0 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/idistance/TestIDistance.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/idistance/IDistanceTest.java @@ -28,15 +28,16 @@ import org.junit.Test; import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.FarthestPointsInitialMeans; import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase; import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction; -import de.lmu.ifi.dbs.elki.index.AbstractTestIndexStructures; +import de.lmu.ifi.dbs.elki.index.AbstractIndexStructureTest; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; /** * Unit test for the iDistance index. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestIDistance extends AbstractTestIndexStructures { +public class IDistanceTest extends AbstractIndexStructureTest { /** * Test {@link InMemoryIDistanceIndex}. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/invertedlist/TestInMemoryInvertedIndex.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/invertedlist/InMemoryInvertedIndexTest.java index ca325176..7882c4c1 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/invertedlist/TestInMemoryInvertedIndex.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/invertedlist/InMemoryInvertedIndexTest.java @@ -26,15 +26,16 @@ package de.lmu.ifi.dbs.elki.index.invertedlist; import org.junit.Test; import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase; -import de.lmu.ifi.dbs.elki.index.AbstractTestIndexStructures; +import de.lmu.ifi.dbs.elki.index.AbstractIndexStructureTest; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; /** * Unit test for the iDistance index. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestInMemoryInvertedIndex extends AbstractTestIndexStructures { +public class InMemoryInvertedIndexTest extends AbstractIndexStructureTest { /** * Test {@link InMemoryInvertedIndex}. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/CosineHashFunctionFamilyTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/CosineHashFunctionFamilyTest.java index 13b6dfea..cbe7eefe 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/CosineHashFunctionFamilyTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/CosineHashFunctionFamilyTest.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Unit test for random hyperplane / cosine distance. * * @author Evgeniy Faerman + * @since 0.7.0 */ public class CosineHashFunctionFamilyTest extends AbstractSimpleAlgorithmTest implements JUnit4Test { @Test diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/preprocessed/TestMaterializedKNNAndRKNNPreprocessor.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/preprocessed/MaterializedKNNAndRKNNPreprocessorTest.java index cbe374f9..e5deb7fd 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/preprocessed/TestMaterializedKNNAndRKNNPreprocessor.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/preprocessed/MaterializedKNNAndRKNNPreprocessorTest.java @@ -72,8 +72,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * * * @author Elke Achtert + * @since 0.4.0 */ -public class TestMaterializedKNNAndRKNNPreprocessor implements JUnit4Test { +public class MaterializedKNNAndRKNNPreprocessorTest implements JUnit4Test { // the following values depend on the data set used! static String dataset = "data/testdata/unittests/3clusters-and-noise-2d.csv"; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/CoverTreeTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/CoverTreeTest.java new file mode 100644 index 00000000..9531d802 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/CoverTreeTest.java @@ -0,0 +1,50 @@ +package de.lmu.ifi.dbs.elki.index.tree.metrical.covertree; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase; +import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction; +import de.lmu.ifi.dbs.elki.index.AbstractIndexStructureTest; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Unit test for the Cover-tree. + * + * @author Erich Schubert + * @since 0.7.0 + */ +public class CoverTreeTest extends AbstractIndexStructureTest { + /** + * Test {@link CoverTree} using a file based database connection. + */ + @Test + public void testCovertree() { + ListParameterization metparams = new ListParameterization(); + metparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, CoverTree.Factory.class); + metparams.addParameter(CoverTree.Factory.Parameterizer.DISTANCE_FUNCTION_ID, EuclideanDistanceFunction.class); + testExactEuclidean(metparams, CoverTree.CoverTreeKNNQuery.class, CoverTree.CoverTreeRangeQuery.class); + } +} diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/SimplifiedCoverTreeTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/SimplifiedCoverTreeTest.java new file mode 100644 index 00000000..d63a5ecc --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/SimplifiedCoverTreeTest.java @@ -0,0 +1,50 @@ +package de.lmu.ifi.dbs.elki.index.tree.metrical.covertree; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase; +import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction; +import de.lmu.ifi.dbs.elki.index.AbstractIndexStructureTest; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Unit test for the Cover-tree. + * + * @author Erich Schubert + * @since 0.7.0 + */ +public class SimplifiedCoverTreeTest extends AbstractIndexStructureTest { + /** + * Test {@link SimplifiedCoverTree} using a file based database connection. + */ + @Test + public void testCovertree() { + ListParameterization metparams = new ListParameterization(); + metparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, SimplifiedCoverTree.Factory.class); + metparams.addParameter(SimplifiedCoverTree.Factory.Parameterizer.DISTANCE_FUNCTION_ID, EuclideanDistanceFunction.class); + testExactEuclidean(metparams, SimplifiedCoverTree.CoverTreeKNNQuery.class, SimplifiedCoverTree.CoverTreeRangeQuery.class); + } +} diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/TestMTree.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeTest.java index b4eb7bc9..f4188e91 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/TestMTree.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeTest.java @@ -26,7 +26,7 @@ package de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.mtree; import org.junit.Test; import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase; -import de.lmu.ifi.dbs.elki.index.AbstractTestIndexStructures; +import de.lmu.ifi.dbs.elki.index.AbstractIndexStructureTest; import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.query.MetricalIndexKNNQuery; import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.query.MetricalIndexRangeQuery; import de.lmu.ifi.dbs.elki.persistent.AbstractPageFileFactory; @@ -36,8 +36,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * Unit test for the M-tree. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestMTree extends AbstractTestIndexStructures { +public class MTreeTest extends AbstractIndexStructureTest { /** * Test {@link MTree} using a file based database connection. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/TestMinimalisticMemoryKDTree.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/MinimalisticMemoryKDTreeTest.java index 70fef1c3..c612f44c 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/TestMinimalisticMemoryKDTree.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/MinimalisticMemoryKDTreeTest.java @@ -26,15 +26,16 @@ package de.lmu.ifi.dbs.elki.index.tree.spatial.kd; import org.junit.Test; import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase; -import de.lmu.ifi.dbs.elki.index.AbstractTestIndexStructures; +import de.lmu.ifi.dbs.elki.index.AbstractIndexStructureTest; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; /** * Unit test for the k-d-tree index. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestMinimalisticMemoryKDTree extends AbstractTestIndexStructures { +public class MinimalisticMemoryKDTreeTest extends AbstractIndexStructureTest { /** * Test {@link MinimalisticMemoryKDTree} using a file based database connection. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/TestSmallMemoryKDTree.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/SmallMemoryKDTreeTest.java index c5939ec1..fe12335f 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/TestSmallMemoryKDTree.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/SmallMemoryKDTreeTest.java @@ -26,15 +26,16 @@ package de.lmu.ifi.dbs.elki.index.tree.spatial.kd; import org.junit.Test; import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase; -import de.lmu.ifi.dbs.elki.index.AbstractTestIndexStructures; +import de.lmu.ifi.dbs.elki.index.AbstractIndexStructureTest; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; /** * Unit test for the k-d-tree index. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestSmallMemoryKDTree extends AbstractTestIndexStructures { +public class SmallMemoryKDTreeTest extends AbstractIndexStructureTest { /** * Test {@link SmallMemoryKDTree} using a file based database connection. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeTest.java new file mode 100644 index 00000000..3a1a64c0 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeTest.java @@ -0,0 +1,362 @@ +package de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.rstar; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase; +import de.lmu.ifi.dbs.elki.index.AbstractIndexStructureTest; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.AbstractRStarTreeFactory; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.query.RStarTreeKNNQuery; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.query.RStarTreeRangeQuery; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.AdaptiveSortTileRecursiveBulkSplit; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.FileOrderBulkSplit; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.MaxExtensionBulkSplit; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.MaxExtensionSortTileRecursiveBulkSplit; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.OneDimSortBulkSplit; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.SortTileRecursiveBulkSplit; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.SpatialSortBulkSplit; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.ApproximativeLeastOverlapInsertionStrategy; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.AngTanLinearSplit; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.GreeneSplit; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.RTreeLinearSplit; +import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.RTreeQuadraticSplit; +import de.lmu.ifi.dbs.elki.math.spacefillingcurves.BinarySplitSpatialSorter; +import de.lmu.ifi.dbs.elki.math.spacefillingcurves.HilbertSpatialSorter; +import de.lmu.ifi.dbs.elki.math.spacefillingcurves.PeanoSpatialSorter; +import de.lmu.ifi.dbs.elki.math.spacefillingcurves.ZCurveSpatialSorter; +import de.lmu.ifi.dbs.elki.persistent.AbstractPageFileFactory; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; + +/** + * Unit test for the R*-tree index. + * + * @author Erich Schubert + * @since 0.7.0 + */ +public class RStarTreeTest extends AbstractIndexStructureTest { + /** + * Test {@link RStarTree} using a file based database connection. + */ + @Test + public void testRStarTree() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} using a file based database connection. With "fast" + * mode enabled on an extreme level (since this should only reduce + * performance, not correctness!) + */ + @Test + public void testRStarTreeFast() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractRStarTreeFactory.Parameterizer.INSERTION_STRATEGY_ID, ApproximativeLeastOverlapInsertionStrategy.class); + spatparams.addParameter(ApproximativeLeastOverlapInsertionStrategy.Parameterizer.INSERTION_CANDIDATES_ID, 1); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractRStarTreeFactory.Parameterizer.INSERTION_STRATEGY_ID, ApproximativeLeastOverlapInsertionStrategy.class); + spatparams.addParameter(ApproximativeLeastOverlapInsertionStrategy.Parameterizer.INSERTION_CANDIDATES_ID, 1); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} using {@link RTreeLinearSplit} + */ + @Test + public void testRTreeLinearSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.SPLIT_STRATEGY_ID, RTreeLinearSplit.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.SPLIT_STRATEGY_ID, RTreeLinearSplit.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} using {@link RTreeQuadraticSplit} + */ + @Test + public void testRTreeQuadraticSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.SPLIT_STRATEGY_ID, RTreeQuadraticSplit.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.SPLIT_STRATEGY_ID, RTreeQuadraticSplit.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} using {@link GreeneSplit} + */ + @Test + public void testRTreeGreeneSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.SPLIT_STRATEGY_ID, GreeneSplit.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.SPLIT_STRATEGY_ID, GreeneSplit.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} using {@link RTreeLinearSplit} + */ + @Test + public void testRTreeAngTanLinearSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.SPLIT_STRATEGY_ID, AngTanLinearSplit.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.SPLIT_STRATEGY_ID, AngTanLinearSplit.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} bulk loaded using {@link FileOrderBulkSplit} + */ + @Test + public void testFileOrderBulkSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, FileOrderBulkSplit.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, FileOrderBulkSplit.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} bulk loaded using {@link MaxExtensionBulkSplit} + */ + @Test + public void testMaxExtensionBulkSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, MaxExtensionBulkSplit.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, MaxExtensionBulkSplit.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} bulk loaded using {@link OneDimSortBulkSplit} + */ + @Test + public void testOneDimSortBulkSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, OneDimSortBulkSplit.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, OneDimSortBulkSplit.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} bulk loaded using {@link SpatialSortBulkSplit} with + * {@link ZCurveSpatialSorter} + */ + @Test + public void testZCurveSpatialSortBulkSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SpatialSortBulkSplit.class); + spatparams.addParameter(SpatialSortBulkSplit.Parameterizer.SORTER_ID, ZCurveSpatialSorter.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SpatialSortBulkSplit.class); + spatparams.addParameter(SpatialSortBulkSplit.Parameterizer.SORTER_ID, ZCurveSpatialSorter.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} bulk loaded using {@link SpatialSortBulkSplit} with + * {@link HilbertSpatialSorter} + */ + @Test + public void testHilbertSpatialSortBulkSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SpatialSortBulkSplit.class); + spatparams.addParameter(SpatialSortBulkSplit.Parameterizer.SORTER_ID, HilbertSpatialSorter.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SpatialSortBulkSplit.class); + spatparams.addParameter(SpatialSortBulkSplit.Parameterizer.SORTER_ID, HilbertSpatialSorter.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} bulk loaded using {@link SpatialSortBulkSplit} with + * {@link PeanoSpatialSorter} + */ + @Test + public void testPeanoSpatialSortBulkSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SpatialSortBulkSplit.class); + spatparams.addParameter(SpatialSortBulkSplit.Parameterizer.SORTER_ID, PeanoSpatialSorter.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SpatialSortBulkSplit.class); + spatparams.addParameter(SpatialSortBulkSplit.Parameterizer.SORTER_ID, PeanoSpatialSorter.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} bulk loaded using {@link SpatialSortBulkSplit} with + * {@link BinarySplitSpatialSorter} + */ + @Test + public void testBinarySplitSpatialSortBulkSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SpatialSortBulkSplit.class); + spatparams.addParameter(SpatialSortBulkSplit.Parameterizer.SORTER_ID, BinarySplitSpatialSorter.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SpatialSortBulkSplit.class); + spatparams.addParameter(SpatialSortBulkSplit.Parameterizer.SORTER_ID, BinarySplitSpatialSorter.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} bulk loaded using {@link SortTileRecursiveBulkSplit} + */ + @Test + public void testSortTileRecursiveBulkSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SortTileRecursiveBulkSplit.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SortTileRecursiveBulkSplit.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} bulk loaded using + * {@link MaxExtensionSortTileRecursiveBulkSplit} + */ + @Test + public void testMaxExtensionSortTileRecursiveBulkSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, MaxExtensionSortTileRecursiveBulkSplit.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, MaxExtensionSortTileRecursiveBulkSplit.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } + + /** + * Test {@link RStarTree} bulk loaded using + * {@link AdaptiveSortTileRecursiveBulkSplit} + */ + @Test + public void testAdaptiveSortTileRecursiveBulkSplit() { + ListParameterization spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, AdaptiveSortTileRecursiveBulkSplit.class); + testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + // + spatparams = new ListParameterization(); + spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); + spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); + spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, AdaptiveSortTileRecursiveBulkSplit.class); + testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); + } +} diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/TestRStarTree.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/TestRStarTree.java deleted file mode 100644 index db88d600..00000000 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/TestRStarTree.java +++ /dev/null @@ -1,99 +0,0 @@ -package de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.rstar; - -/* - This file is part of ELKI: - Environment for Developing KDD-Applications Supported by Index-Structures - - Copyright (C) 2015 - Ludwig-Maximilians-Universität München - Lehr- und Forschungseinheit für Datenbanksysteme - ELKI Development Team - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Affero General Public License for more details. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -import org.junit.Test; - -import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase; -import de.lmu.ifi.dbs.elki.index.AbstractTestIndexStructures; -import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.AbstractRStarTreeFactory; -import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.query.RStarTreeKNNQuery; -import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.query.RStarTreeRangeQuery; -import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.bulk.SortTileRecursiveBulkSplit; -import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.insert.ApproximativeLeastOverlapInsertionStrategy; -import de.lmu.ifi.dbs.elki.persistent.AbstractPageFileFactory; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; - -/** - * Unit test for the R*-tree index. - * - * @author Erich Schubert - */ -public class TestRStarTree extends AbstractTestIndexStructures { - /** - * Test {@link RStarTree} using a file based database connection. - */ - @Test - public void testRStarTree() { - ListParameterization spatparams = new ListParameterization(); - spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); - spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); - testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); - // - spatparams = new ListParameterization(); - spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); - spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); - testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); - } - - /** - * Test {@link RStarTree} using a file based database connection. With "fast" - * mode enabled on an extreme level (since this should only reduce - * performance, not correctness!) - */ - @Test - public void testRStarTreeFast() { - ListParameterization spatparams = new ListParameterization(); - spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); - spatparams.addParameter(AbstractRStarTreeFactory.Parameterizer.INSERTION_STRATEGY_ID, ApproximativeLeastOverlapInsertionStrategy.class); - spatparams.addParameter(ApproximativeLeastOverlapInsertionStrategy.Parameterizer.INSERTION_CANDIDATES_ID, 1); - spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); - testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); - // - spatparams = new ListParameterization(); - spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); - spatparams.addParameter(AbstractRStarTreeFactory.Parameterizer.INSERTION_STRATEGY_ID, ApproximativeLeastOverlapInsertionStrategy.class); - spatparams.addParameter(ApproximativeLeastOverlapInsertionStrategy.Parameterizer.INSERTION_CANDIDATES_ID, 1); - spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); - testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); - } - - /** - * Test {@link RStarTree} bulk loaded using {@link SortTileRecursiveBulkSplit} - */ - @Test - public void testSTRTree() { - ListParameterization spatparams = new ListParameterization(); - spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); - spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); - spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SortTileRecursiveBulkSplit.class); - testExactEuclidean(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); - // - spatparams = new ListParameterization(); - spatparams.addParameter(StaticArrayDatabase.Parameterizer.INDEX_ID, RStarTreeFactory.class); - spatparams.addParameter(AbstractPageFileFactory.Parameterizer.PAGE_SIZE_ID, 300); - spatparams.addParameter(RStarTreeFactory.Parameterizer.BULK_SPLIT_ID, SortTileRecursiveBulkSplit.class); - testExactCosine(spatparams, RStarTreeKNNQuery.class, RStarTreeRangeQuery.class); - } -} diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/vafile/TestPartialVAFile.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/vafile/PartialVAFileTest.java index 4097256b..9060330c 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/vafile/TestPartialVAFile.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/vafile/PartialVAFileTest.java @@ -26,15 +26,16 @@ package de.lmu.ifi.dbs.elki.index.vafile; import org.junit.Test; import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase; -import de.lmu.ifi.dbs.elki.index.AbstractTestIndexStructures; +import de.lmu.ifi.dbs.elki.index.AbstractIndexStructureTest; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; /** * Unit test for the partial VAfile index. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestPartialVAFile extends AbstractTestIndexStructures { +public class PartialVAFileTest extends AbstractIndexStructureTest { /** * Test {@link PartialVAFile} using a file based database connection. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/vafile/TestVAFile.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/vafile/VAFileTest.java index 7a49c685..a345b256 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/index/vafile/TestVAFile.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/index/vafile/VAFileTest.java @@ -26,15 +26,16 @@ package de.lmu.ifi.dbs.elki.index.vafile; import org.junit.Test; import de.lmu.ifi.dbs.elki.database.StaticArrayDatabase; -import de.lmu.ifi.dbs.elki.index.AbstractTestIndexStructures; +import de.lmu.ifi.dbs.elki.index.AbstractIndexStructureTest; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; /** * Unit test for the VAfile index. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestVAFile extends AbstractTestIndexStructures { +public class VAFileTest extends AbstractIndexStructureTest { /** * Test {@link VAFile} using a file based database connection. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/logging/TestOutputStreamLogger.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/logging/OutputStreamLoggerTest.java index bbde0e42..e5034d8d 100755 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/logging/TestOutputStreamLogger.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/logging/OutputStreamLoggerTest.java @@ -37,9 +37,10 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Small experiment to assert the console output logger works as expected. * * @author Erich Schubert + * @since 0.2 * */ -public class TestOutputStreamLogger implements JUnit4Test { +public class OutputStreamLoggerTest implements JUnit4Test { /** * Write a couple of messages to the console output writer and compare the * resulting characters. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestAffineTransformation.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/AffineTransformationTest.java index 7c39d691..e3e01d6d 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestAffineTransformation.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/AffineTransformationTest.java @@ -37,9 +37,10 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * JUnit Test for the class {@link AffineTransformation} * * @author Erich Schubert + * @since 0.2 * */ -public class TestAffineTransformation implements JUnit4Test { +public class AffineTransformationTest implements JUnit4Test { /** * Test identity transform */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestKernelDensityFitting.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/KernelDensityFittingTest.java index 3ec64c63..65c798f0 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestKernelDensityFitting.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/KernelDensityFittingTest.java @@ -51,8 +51,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet * JUnit test that does a complete Kernel and Levenberg-Marquadt fitting. * * @author Erich Schubert + * @since 0.2 */ -public class TestKernelDensityFitting implements JUnit4Test { +public class KernelDensityFittingTest implements JUnit4Test { // the following values depend on the data set used! String dataset = "data/testdata/unittests/gaussian-1d-for-fitting.csv"; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestLevenbergMarquardtGaussianFitting.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/LevenbergMarquardtGaussianFittingTest.java index 54b56b99..6bc171e1 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestLevenbergMarquardtGaussianFitting.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/LevenbergMarquardtGaussianFittingTest.java @@ -36,9 +36,10 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.fitting.LevenbergMarquardtMethod; * distribution. * * @author Erich Schubert + * @since 0.2 * */ -public class TestLevenbergMarquardtGaussianFitting implements JUnit4Test { +public class LevenbergMarquardtGaussianFittingTest implements JUnit4Test { /** * Evaluate on a symmetric Gaussian distribution. Traditional estimation * already has the mean quite good, but is far off on the stddev. The improved diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestMathUtil.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/MathUtilTest.java index 9f180ef9..bc5fb3b3 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestMathUtil.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/MathUtilTest.java @@ -34,10 +34,11 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; /** * Unit test for some basic math functions. - * + * * @author Erich Schubert + * @since 0.4.1 */ -public class TestMathUtil implements JUnit4Test { +public class MathUtilTest implements JUnit4Test { @Test public void testPearsonCorrelation() { final int size = 1000; @@ -48,7 +49,7 @@ public class TestMathUtil implements JUnit4Test { double[] weight2 = new double[size]; Random r = new Random(seed); - for (int i = 0; i < size; i++) { + for(int i = 0; i < size; i++) { data1[i] = r.nextDouble(); data2[i] = r.nextDouble(); weight1[i] = 1.0; @@ -88,7 +89,7 @@ public class TestMathUtil implements JUnit4Test { @Test public void testFloatToDouble() { Random r = new Random(1l); - for (int i = 0; i < 10000; i++) { + for(int i = 0; i < 10000; i++) { final double dbl = Double.longBitsToDouble(r.nextLong()); final float flt = (float) dbl; final double uppd = MathUtil.floatToDoubleUpper(flt); @@ -101,4 +102,12 @@ public class TestMathUtil implements JUnit4Test { assertTrue("Expected value to round to the same float.", flt == lowf || Double.isNaN(flt)); } } + + @Test + public void testPowi() { + assertEquals("Power incorrect", 0.01, MathUtil.powi(0.1, 2), 1e-13); + assertEquals("Power incorrect", 0.001, MathUtil.powi(0.1, 3), 1e-13); + assertEquals("Power incorrect", 0.0001, MathUtil.powi(0.1, 4), 1e-13); + assertEquals("Power incorrect", 0.00001, MathUtil.powi(0.1, 5), 1e-13); + } } diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestMatrix.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/MatrixTest.java index a7eab849..37876fef 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestMatrix.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/MatrixTest.java @@ -30,7 +30,13 @@ import org.junit.Test; import de.lmu.ifi.dbs.elki.JUnit4Test; import de.lmu.ifi.dbs.elki.math.linearalgebra.Matrix; -public class TestMatrix implements JUnit4Test { +/** + * Test some basic matrix operations. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class MatrixTest implements JUnit4Test { @Test public void testTransposedOperations() { diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestMean.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/MeanTest.java index eae531e4..a9783757 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestMean.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/MeanTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Test the Mean class. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestMean implements JUnit4Test { +public class MeanTest implements JUnit4Test { @Test public void testInfinity() { Mean m = new Mean(); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestSlidingVariance.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/MeanVarianceTest.java index 3b531f63..76ae56a1 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestSlidingVariance.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/MeanVarianceTest.java @@ -34,8 +34,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Unit test {@link MeanVariance} with negative weights. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestSlidingVariance implements JUnit4Test { +public class MeanVarianceTest implements JUnit4Test { /** * Size of test data set. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestSinCosTable.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/SinCosTableTest.java index 4a346a4d..eaf9f1b4 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestSinCosTable.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/SinCosTableTest.java @@ -1,11 +1,4 @@ package de.lmu.ifi.dbs.elki.math; - -import static org.junit.Assert.assertEquals; - -import org.junit.Test; - -import de.lmu.ifi.dbs.elki.JUnit4Test; - /* This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures @@ -29,19 +22,30 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; along with this program. If not, see <http://www.gnu.org/licenses/>. */ -public class TestSinCosTable implements JUnit4Test { +import static org.junit.Assert.assertEquals; + +import org.junit.Test; +import de.lmu.ifi.dbs.elki.JUnit4Test; + +/** + * Test the sin-cos lookup table. + * + * @author Erich Schubert + * @since 0.4.0 + */ +public class SinCosTableTest implements JUnit4Test { @Test public void testSinCosTable() { - doTestSinCosTable(360); - doTestSinCosTable(142); // Divisible by two - doTestSinCosTable(17); - doTestSinCosTable(131); // Prime. + doSinCosTableTest(360); + doSinCosTableTest(142); // Divisible by two + doSinCosTableTest(17); + doSinCosTableTest(131); // Prime. } - protected void doTestSinCosTable(int steps) { + protected void doSinCosTableTest(int steps) { SinCosTable table = SinCosTable.make(steps); - for (int i = -steps; i < 2 * steps; i++) { + for(int i = -steps; i < 2 * steps; i++) { double angle = Math.toRadians(360. * i / steps); assertEquals("Cosine does not match at i=" + i + " a=" + angle, Math.cos(angle), table.cos(i), 1E-10); assertEquals("Sine does not match at i=" + i + " a=" + angle, Math.sin(angle), table.sin(i), 1E-10); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestStatisticalMoments.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/StatisticalMomentsTest.java index 976ec6b8..51106508 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestStatisticalMoments.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/StatisticalMomentsTest.java @@ -33,8 +33,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Unit test to check our statistical moments class for correctness. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestStatisticalMoments implements JUnit4Test { +public class StatisticalMomentsTest implements JUnit4Test { @Test public void testTiny() { double[] data = new double[] { 222, 1122, 45444 }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/geodesy/TestEarthModels.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/geodesy/EarthModelsTest.java index 24f49f1f..1d72e521 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/geodesy/TestEarthModels.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/geodesy/EarthModelsTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * give different values. But in the end, it's always just an approximation. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestEarthModels implements JUnit4Test { +public class EarthModelsTest implements JUnit4Test { // New York City final double[] NEW_YORK = new double[] { 40.67, -73.94 }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/geometry/TestPrimsMinimumSpanningTree.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/geometry/PrimsMinimumSpanningTreeTest.java index cb9f518e..6672fe29 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/geometry/TestPrimsMinimumSpanningTree.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/geometry/PrimsMinimumSpanningTreeTest.java @@ -34,8 +34,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Test class for Prim's minmum spanning tree algorithm. * * @author Erich Schubert + * @since 0.5.5 */ -public class TestPrimsMinimumSpanningTree implements JUnit4Test { +public class PrimsMinimumSpanningTreeTest implements JUnit4Test { @Test public void testSimple() { // A simple test. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/scales/TestLinearScale.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/scales/LinearScaleTest.java index 3e088b17..61988392 100755 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/scales/TestLinearScale.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/scales/LinearScaleTest.java @@ -34,9 +34,10 @@ import de.lmu.ifi.dbs.elki.math.scales.LinearScale; * Test class to test rounding of the linear scale. * * @author Erich Schubert + * @since 0.2 * */ -public class TestLinearScale implements JUnit4Test { +public class LinearScaleTest implements JUnit4Test { /** * Produces a simple linear scale and verifies the tick lines are placed as diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestAbstractDependenceMeasure.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/AbstractDependenceMeasureTest.java index 866f819a..4a938038 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestAbstractDependenceMeasure.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/AbstractDependenceMeasureTest.java @@ -34,8 +34,9 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayLikeUtil; * Validate jensen shannon dependence. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestAbstractDependenceMeasure implements JUnit4Test { +public class AbstractDependenceMeasureTest implements JUnit4Test { @Test public void testIndexing() { double[] data = { 1e-10, 1, 1e-5, 1, 2, 1 }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestCorrelationDependenceMeasure.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/CorrelationDependenceMeasureTest.java index 00e737c8..afe080c2 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestCorrelationDependenceMeasure.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/CorrelationDependenceMeasureTest.java @@ -36,8 +36,9 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayLikeUtil; * Validate correlation by comparing to the results of R. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestCorrelationDependenceMeasure implements JUnit4Test { +public class CorrelationDependenceMeasureTest implements JUnit4Test { double[][] data = { // { 1, 2, 3, 4 }, // { 1, 3, 5, 7 }, // diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestDistanceCorrelationDependenceMeasure.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/DistanceCorrelationDependenceMeasureTest.java index 8c000e30..bcf493be 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestDistanceCorrelationDependenceMeasure.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/DistanceCorrelationDependenceMeasureTest.java @@ -36,8 +36,9 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayLikeUtil; * Validate dCor by comparing to output of the official R version. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestDistanceCorrelationDependenceMeasure implements JUnit4Test { +public class DistanceCorrelationDependenceMeasureTest implements JUnit4Test { double[][] data = { // { 1, 2, 3, 4 }, // { 1, 3, 5, 7 }, // diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestJensenShannonEquiwidthDependenceMeasure.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/JensenShannonEquiwidthDependenceMeasureTest.java index 30019106..7d30b9a0 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestJensenShannonEquiwidthDependenceMeasure.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/JensenShannonEquiwidthDependenceMeasureTest.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayLikeUtil; * Validate jensen shannon dependence. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestJensenShannonEquiwidthDependenceMeasure implements JUnit4Test { +public class JensenShannonEquiwidthDependenceMeasureTest implements JUnit4Test { double[][] data = { // { 1, 2, 3, 4 }, // { 1, 3, 5, 7 }, // diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestMutualInformationEquiwidthDependenceMeasure.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/MutualInformationEquiwidthDependenceMeasureTest.java index 07c2ee32..9807557b 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestMutualInformationEquiwidthDependenceMeasure.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/MutualInformationEquiwidthDependenceMeasureTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayLikeUtil; * Validate correlation by comparing to manual computation. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestMutualInformationEquiwidthDependenceMeasure implements JUnit4Test { +public class MutualInformationEquiwidthDependenceMeasureTest implements JUnit4Test { double[][] data = { // { 1, 2, 3, 4 }, // { 1, 3, 5, 7 }, // diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestSpearmanCorrelationDependenceMeasure.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SpearmanCorrelationDependenceMeasureTest.java index 11e347bb..ad056820 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/TestSpearmanCorrelationDependenceMeasure.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SpearmanCorrelationDependenceMeasureTest.java @@ -36,8 +36,9 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayLikeUtil; * Validate correlation by comparing to the results of R. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestSpearmanCorrelationDependenceMeasure implements JUnit4Test { +public class SpearmanCorrelationDependenceMeasureTest implements JUnit4Test { double[][] data = { // { 1, 2, 3, 4 }, // { 1, 3, 5, 700 }, // diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/AbstractDistributionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/AbstractDistributionTest.java index 54ba4208..8b202e13 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/AbstractDistributionTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/AbstractDistributionTest.java @@ -29,6 +29,7 @@ import static org.junit.Assert.assertTrue; * Abstract base class for distribution unit testing. * * @author Erich Schubert + * @since 0.5.0 */ public class AbstractDistributionTest { public void checkPDF(Distribution d, double[] x, double[] expected, double err) { diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestBetaDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/BetaDistributionTest.java index dba4b8cb..3c95fc80 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestBetaDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/BetaDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using GNU R and SciPy. * * @author Erich Schubert + * @since 0.5.0 */ -public class TestBetaDistribution extends AbstractDistributionTest implements JUnit4Test { +public class BetaDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 1e-10, 1e-05, 0.1, 0.1234567, 0.2, 0.271828182846, 0.3, 0.314159265359, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.71828182846, 3.14159265359 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestChiSquaredDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ChiSquaredDistributionTest.java index 2a9e9ae9..f2c0a85a 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestChiSquaredDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ChiSquaredDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using GNU R and SciPy. * * @author Erich Schubert + * @since 0.5.0 */ -public class TestChiSquaredDistribution extends AbstractDistributionTest implements JUnit4Test { +public class ChiSquaredDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 1e-05, 1e-10, 0.1234567, 3.14159265359, 2.71828182846, 0.314159265359, 0.271828182846 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestExponentialDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentialDistributionTest.java index e024eada..f5dc2e03 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestExponentialDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentialDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using GNU R and SciPy. * * @author Erich Schubert + * @since 0.5.5 */ -public class TestExponentialDistribution extends AbstractDistributionTest implements JUnit4Test { +public class ExponentialDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 1e-10, 1e-05, 0.1, 0.1234567, 0.2, 0.271828182846, 0.3, 0.314159265359, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.71828182846, 3.14159265359 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestExponentiallyModifiedGaussianDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentiallyModifiedGaussianDistributionTest.java index 69c8443d..6012b548 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestExponentiallyModifiedGaussianDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentiallyModifiedGaussianDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using GNU R and SciPy. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestExponentiallyModifiedGaussianDistribution extends AbstractDistributionTest implements JUnit4Test { +public class ExponentiallyModifiedGaussianDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 1e-10, 1e-05, 0.1, 0.1234567, 0.2, 0.2718281828459045, 0.3, 0.3141592653589793, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.718281828459045, 3.141592653589793 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestGammaDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GammaDistributionTest.java index 9fa12068..fa1fe647 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestGammaDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GammaDistributionTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayLikeUtil; * The reference values were computed using GNU R and SciPy. * * @author Erich Schubert + * @since 0.5.0 */ -public class TestGammaDistribution extends AbstractDistributionTest implements JUnit4Test { +public class GammaDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 1e-05, 1e-10, 0.1234567, 3.14159265359, 2.71828182846, 0.314159265359, 0.271828182846 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestGeneralizedExtremeValueDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedExtremeValueDistributionTest.java index c4b0fce2..85ad93e3 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestGeneralizedExtremeValueDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedExtremeValueDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using SciPy. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestGeneralizedExtremeValueDistribution extends AbstractDistributionTest implements JUnit4Test { +public class GeneralizedExtremeValueDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 1e-10, 1e-05, 0.1, 0.1234567, 0.2, 0.271828182846, 0.3, 0.314159265359, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.71828182846, 3.14159265359 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestGeneralizedLogisticDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedLogisticDistributionTest.java index ca3d8fe9..c9b1baef 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestGeneralizedLogisticDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedLogisticDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using GNU R and SciPy. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestGeneralizedLogisticDistribution extends AbstractDistributionTest implements JUnit4Test { +public class GeneralizedLogisticDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 1e-10, 1e-05, 0.1, 0.1234567, 0.2, 0.271828182846, 0.3, 0.314159265359, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.71828182846, 3.14159265359 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestGeneralizedParetoDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedParetoDistributionTest.java index 23328e4d..83025a31 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestGeneralizedParetoDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedParetoDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using SciPy. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestGeneralizedParetoDistribution extends AbstractDistributionTest implements JUnit4Test { +public class GeneralizedParetoDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 1e-10, 1e-05, 0.1, 0.1234567, 0.2, 0.271828182846, 0.3, 0.314159265359, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.71828182846, 3.14159265359 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestGumbelDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GumbelDistributionTest.java index 9efec3cf..9c7223f3 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestGumbelDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GumbelDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using SciPy. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestGumbelDistribution extends AbstractDistributionTest implements JUnit4Test { +public class GumbelDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 1e-10, 1e-05, 0.1, 0.1234567, 0.2, 0.271828182846, 0.3, 0.314159265359, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.71828182846, 3.14159265359 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/HaltonUniformDistributionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/HaltonUniformDistributionTest.java new file mode 100644 index 00000000..2c70e509 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/HaltonUniformDistributionTest.java @@ -0,0 +1,91 @@ +package de.lmu.ifi.dbs.elki.math.statistics.distribution; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; + +/** + * Unit test for the Halton pseudo-Uniform distribution in ELKI. + * + * @author Erich Schubert + * @since 0.7.1 + */ +public class HaltonUniformDistributionTest extends AbstractDistributionTest implements JUnit4Test { + public static final double[] P_CDFPDF = { // + 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 1e-05, 1e-10, 0.1234567, 3.14159265359, 2.71828182846, 0.314159265359, 0.271828182846 // + }; + + public static final double[] P_PROBIT = { // + 0.0001, 0.001, 0.01, 0.1, 0.25, 0.5, 0.75, 0.9, 0.99, 0.999, 0.9999 // + }; + + @Test + public void testPDF() { + double[] buf = new double[P_CDFPDF.length]; + for(double l : new double[] { -1, 0, .1, 1 }) { + for(double h : new double[] { -1, 0, .1, 1, 2, 10 }) { + if(l < h) { + double w = h - l; + for(int i = 0; i < P_CDFPDF.length; i++) { + buf[i] = (P_CDFPDF[i] >= l && P_CDFPDF[i] < h) ? 1. / w : 0.; + } + checkPDF(new HaltonUniformDistribution(l, h), P_CDFPDF, buf, 1e-15); + } + } + } + } + + @Test + public void testCDF() { + double[] buf = new double[P_CDFPDF.length]; + for(double l : new double[] { -1, 0, .1, 1 }) { + for(double h : new double[] { -1, 0, .1, 1, 2, 10 }) { + if(l < h) { + double w = h - l; + for(int i = 0; i < P_CDFPDF.length; i++) { + buf[i] = P_CDFPDF[i] <= l ? 0. : P_CDFPDF[i] >= h ? 1. : (P_CDFPDF[i] - l) / w; + } + checkCDF(new HaltonUniformDistribution(l, h), P_CDFPDF, buf, 1e-15); + } + } + } + } + + @Test + public void testProbit() { + double[] buf = new double[P_PROBIT.length]; + for(double l : new double[] { -1, 0, .1, 1 }) { + for(double h : new double[] { -1, 0, .1, 1, 2, 10 }) { + if(l < h) { + double w = h - l; + for(int i = 0; i < P_PROBIT.length; i++) { + buf[i] = l + P_PROBIT[i] * w; + } + checkQuantile(new HaltonUniformDistribution(l, h), P_PROBIT, buf, 1e-15); + } + } + } + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestLogGammaAlternateDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogGammaAlternateDistributionTest.java index 436953cc..e3354f3f 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestLogGammaAlternateDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogGammaAlternateDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using GNU R and SciPy. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestLogGammaAlternateDistribution extends AbstractDistributionTest implements JUnit4Test { +public class LogGammaAlternateDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 1e-10, 1e-05, 0.1, 0.1234567, 0.2, 0.271828182846, 0.3, 0.314159265359, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.71828182846, 3.14159265359 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestLogNormalDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogNormalDistributionTest.java index 75284aae..c42ffe89 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestLogNormalDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogNormalDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using GNU R and SciPy. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestLogNormalDistribution extends AbstractDistributionTest implements JUnit4Test { +public class LogNormalDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 1e-10, 1e-05, 0.1, 0.1234567, 0.2, 0.271828182846, 0.3, 0.314159265359, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.71828182846, 3.14159265359 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestLogisticDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogisticDistributionTest.java index 54e90417..b6084401 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestLogisticDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogisticDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using GNU R and SciPy. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestLogisticDistribution extends AbstractDistributionTest implements JUnit4Test { +public class LogisticDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 1e-10, 1e-05, 0.1, 0.1234567, 0.2, 0.271828182846, 0.3, 0.314159265359, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.71828182846, 3.14159265359 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestNormalDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/NormalDistributionTest.java index 79693a60..1a301f3b 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestNormalDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/NormalDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using GNU R and SciPy. * * @author Erich Schubert + * @since 0.5.0 */ -public class TestNormalDistribution extends AbstractDistributionTest implements JUnit4Test { +public class NormalDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 1e-05, 1e-10, 0.1234567, 3.14159265359, 2.71828182846, 0.314159265359, 0.271828182846 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/UniformDistributionTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/UniformDistributionTest.java new file mode 100644 index 00000000..84bff909 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/UniformDistributionTest.java @@ -0,0 +1,91 @@ +package de.lmu.ifi.dbs.elki.math.statistics.distribution; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ +import org.junit.Test; + +import de.lmu.ifi.dbs.elki.JUnit4Test; + +/** + * Unit test for the Uniform distribution in ELKI. + * + * @author Erich Schubert + * @since 0.7.1 + */ +public class UniformDistributionTest extends AbstractDistributionTest implements JUnit4Test { + public static final double[] P_CDFPDF = { // + 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 1e-05, 1e-10, 0.1234567, 3.14159265359, 2.71828182846, 0.314159265359, 0.271828182846 // + }; + + public static final double[] P_PROBIT = { // + 0.0001, 0.001, 0.01, 0.1, 0.25, 0.5, 0.75, 0.9, 0.99, 0.999, 0.9999 // + }; + + @Test + public void testPDF() { + double[] buf = new double[P_CDFPDF.length]; + for(double l : new double[] { -1, 0, .1, 1 }) { + for(double h : new double[] { -1, 0, .1, 1, 2, 10 }) { + if(l < h) { + double w = h - l; + for(int i = 0; i < P_CDFPDF.length; i++) { + buf[i] = (P_CDFPDF[i] >= l && P_CDFPDF[i] < h) ? 1. / w : 0.; + } + checkPDF(new UniformDistribution(l, h), P_CDFPDF, buf, 1e-15); + } + } + } + } + + @Test + public void testCDF() { + double[] buf = new double[P_CDFPDF.length]; + for(double l : new double[] { -1, 0, .1, 1 }) { + for(double h : new double[] { -1, 0, .1, 1, 2, 10 }) { + if(l < h) { + double w = h - l; + for(int i = 0; i < P_CDFPDF.length; i++) { + buf[i] = P_CDFPDF[i] <= l ? 0. : P_CDFPDF[i] >= h ? 1. : (P_CDFPDF[i] - l) / w; + } + checkCDF(new UniformDistribution(l, h), P_CDFPDF, buf, 1e-15); + } + } + } + } + + @Test + public void testProbit() { + double[] buf = new double[P_PROBIT.length]; + for(double l : new double[] { -1, 0, .1, 1 }) { + for(double h : new double[] { -1, 0, .1, 1, 2, 10 }) { + if(l < h) { + double w = h - l; + for(int i = 0; i < P_PROBIT.length; i++) { + buf[i] = l + P_PROBIT[i] * w; + } + checkQuantile(new UniformDistribution(l, h), P_PROBIT, buf, 1e-15); + } + } + } + } +}
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestWeibullDistribution.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/WeibullDistributionTest.java index e7aadbf5..e97d1006 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/TestWeibullDistribution.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/WeibullDistributionTest.java @@ -32,8 +32,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * The reference values were computed using GNU R and SciPy. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestWeibullDistribution extends AbstractDistributionTest implements JUnit4Test { +public class WeibullDistributionTest extends AbstractDistributionTest implements JUnit4Test { public static final double[] P_CDFPDF = { // 1e-10, 1e-05, 0.1, 0.1234567, 0.2, 0.271828182846, 0.3, 0.314159265359, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.71828182846, 3.14159265359 // }; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/tests/TestAndersonDarlingTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/tests/AndersonDarlingTestTest.java index 707d2093..09e8dd46 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/tests/TestAndersonDarlingTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/tests/AndersonDarlingTestTest.java @@ -33,8 +33,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Validate the Anderson Darling test. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestAndersonDarlingTest implements JUnit4Test { +public class AndersonDarlingTestTest implements JUnit4Test { double[][] noncentral = { // { -1.877827740862672, -1.2459409569318343, -0.61175121460353787, -0.55626980422641181, // -0.35332777321703612, -0.24551480507545068, -0.23557108046219447, -0.080637593585376352, // diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/tests/TestStandardizedTwoSampleAndersonDarlingTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/tests/StandardizedTwoSampleAndersonDarlingTestTest.java index 5f9f76cf..f7cd0123 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/tests/TestStandardizedTwoSampleAndersonDarlingTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/statistics/tests/StandardizedTwoSampleAndersonDarlingTestTest.java @@ -33,8 +33,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Validate the two-sample anderson darling test. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestStandardizedTwoSampleAndersonDarlingTest implements JUnit4Test { +public class StandardizedTwoSampleAndersonDarlingTestTest implements JUnit4Test { // Table 4, Scholz and Stephens (1987, p.922) double[][] pairs = { // { 38.7, 41.5, 43.8, 44.5, 45.5, 46.0, 47.7, 58.0 },// diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestWeightFunctions.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/weightfunctions/WeightFunctionsTest.java index 3866f35a..ceb00e8a 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/math/TestWeightFunctions.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/math/weightfunctions/WeightFunctionsTest.java @@ -1,4 +1,4 @@ -package de.lmu.ifi.dbs.elki.math; +package de.lmu.ifi.dbs.elki.math.weightfunctions; /* This file is part of ELKI: @@ -41,9 +41,10 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions.WeightFunction * JUnit test to assert consistency of a couple of Weight functions * * @author Erich Schubert + * @since 0.2 * */ -public class TestWeightFunctions implements JUnit4Test { +public class WeightFunctionsTest implements JUnit4Test { /** * Just a 'boring' value test for completeness. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/TestByteArrayUtil.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/ByteArrayUtilTest.java index 80a4abf2..b85ce316 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/TestByteArrayUtil.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/ByteArrayUtilTest.java @@ -35,8 +35,9 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteArrayUtil; * Test some of the varint functions. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestByteArrayUtil implements JUnit4Test { +public class ByteArrayUtilTest implements JUnit4Test { /** * Test the Varint functions */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/TestOnDiskArray.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArrayTest.java index e0948ea8..a67ad5e6 100755 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/TestOnDiskArray.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArrayTest.java @@ -38,9 +38,10 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Test to validate proper OnDiskArray operation. * * @author Erich Schubert + * @since 0.2 */ // TODO: also test with a static sample file. -public class TestOnDiskArray implements JUnit4Test { +public class OnDiskArrayTest implements JUnit4Test { File file = new File("OnDiskArrayTestFile.test.dat"); /** diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/TestOnDiskUpperTriangleMatrix.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/OnDiskUpperTriangleMatrixTest.java index e87c1d47..ade4be8e 100755 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/TestOnDiskUpperTriangleMatrix.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/persistent/OnDiskUpperTriangleMatrixTest.java @@ -37,10 +37,11 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Test the on-disk OnDiskUpperTriangleMatrix class. * * @author Erich Schubert + * @since 0.2 * */ // TODO: also test with a static sample file. -public class TestOnDiskUpperTriangleMatrix implements JUnit4Test { +public class OnDiskUpperTriangleMatrixTest implements JUnit4Test { static File file = new File("UpperTriangleTestFile.test.dat"); /** diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/TestBitsUtil.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/BitsUtilTest.java index 274f5c30..879c4194 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/TestBitsUtil.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/BitsUtilTest.java @@ -34,7 +34,13 @@ import org.junit.Test; import de.lmu.ifi.dbs.elki.JUnit4Test; import de.lmu.ifi.dbs.elki.utilities.BitsUtil; -public class TestBitsUtil implements JUnit4Test { +/** + * Test bit manipulation code. + * + * @author Erich Schubert + * @since 0.5.0 + */ +public class BitsUtilTest implements JUnit4Test { @Test public void testAgainstBigInteger() { BigInteger bigint = new BigInteger("123"); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/TestFormatUtil.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/FormatUtilTest.java index fb0c9d37..7b1e3cae 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/TestFormatUtil.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/FormatUtilTest.java @@ -30,7 +30,13 @@ import org.junit.Test; import de.lmu.ifi.dbs.elki.JUnit4Test; -public class TestFormatUtil implements JUnit4Test { +/** + * Test output formatting. + * + * @author Erich Schubert + * @since 0.6.0 + */ +public class FormatUtilTest implements JUnit4Test { @Test public void testParseDouble() { assertEquals(0., FormatUtil.parseDouble("0"), 0.); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/TestQuickSelect.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/QuickSelectTest.java index eb921dc7..77061517 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/TestQuickSelect.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/QuickSelectTest.java @@ -24,8 +24,10 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures; */ import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; import java.util.Arrays; +import java.util.List; import java.util.Random; import org.junit.Test; @@ -36,8 +38,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Test the QuickSelect math class. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestQuickSelect implements JUnit4Test { +public class QuickSelectTest implements JUnit4Test { /** * Array size to use. */ @@ -107,6 +110,11 @@ public class TestQuickSelect implements JUnit4Test { public void testTies() { double data[] = new double[] { 0.1, 0.1, 0.9, 0.9, 0.5, 0.9, 0.1, 0.1, 0.1, 0.9, 0.9, 0.9, 0.9, 0.1, 0.1 }; assertEquals("Full median incorrect.", 0.5, QuickSelect.median(data), Double.MIN_VALUE); + int half = data.length >> 1; + for (int i = 0; i < data.length; i++) { + assertTrue("Not partially sorted.", data[i] <= data[half] || i > half); + assertTrue("Not partially sorted.", data[i] >= data[half] || i < half); + } } @Test(timeout = 500) @@ -116,5 +124,35 @@ public class TestQuickSelect implements JUnit4Test { // Run QuickSelect QuickSelect.median(data); + int half = data.length >> 1; + for (int i = 0; i < data.length; i++) { + assertTrue("Not partially sorted.", data[i] <= data[half] || i > half); + assertTrue("Not partially sorted.", data[i] >= data[half] || i < half); + } + } + + @Test + public void testTiesInteger() { + int data[] = new int[] { 1, 1, 9, 9, 5, 9, 1, 1, 1, 9, 9, 9, 9, 1, 1 }; + final int half = data.length >> 1; + QuickSelect.quickSelect(data, QuickSelect.INTEGER_ADAPTER, 0, data.length, half); + for (int i = 0; i < data.length; i++) { + assertTrue("Not partially sorted.", data[i] <= data[half] || i > half); + assertTrue("Not partially sorted.", data[i] >= data[half] || i < half); + } + assertEquals("Full median incorrect.", 5, data[half]); } + + @Test + public void testTiesIntegerList() { + List<Integer> data = Arrays.asList(new Integer[] { 1, 1, 9, 9, 5, 9, 1, 1, 1, 9, 9, 9, 9, 1, 1 }); + final int half = data.size() >> 1; + QuickSelect.quickSelect(data, half); + for (int i = 0; i < data.size(); i++) { + assertTrue("Not partially sorted.", data.get(i) <= data.get(half) || i > half); + assertTrue("Not partially sorted.", data.get(i) >= data.get(half) || i < half); + } + assertEquals("Full median incorrect.", 5, data.get(half).intValue()); + } + }
\ No newline at end of file diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/DoubleArrayTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/DoubleArrayTest.java new file mode 100644 index 00000000..1ddea4f6 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/DoubleArrayTest.java @@ -0,0 +1,65 @@ +package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.util.Random; + +import org.junit.Test; + +/** + * Unit test for this arraylist of primitive doubles. + * + * @author Erich Schubert + * @since 0.7.1 + */ +public class DoubleArrayTest { + @Test + public void basicTest() { + DoubleArray arr = new DoubleArray(11); + assertTrue("Allocation does not match.", arr.data.length == 11); + assertTrue("Initial size is not empty.", arr.size() == 0); + + Random r = new Random(0L); + for(int i = 0; i < 11; i++) { + arr.add(r.nextDouble()); + } + assertTrue("Array is not full.", arr.data.length == arr.size()); + arr.add(r.nextDouble()); + assertEquals("Allocation does not match after resize.", 17, arr.data.length); + for(int i = 0; i < 81; i++) { + arr.add(r.nextDouble()); + } + assertEquals("Array does not have expected size.", 11 + 1 + 81, arr.size()); + arr.sort(); + assertEquals("Allocation does not match after resize.", 139, arr.data.length); + double prev = arr.get(0); + for(int i = 1; i < arr.size(); i++) { + double next = arr.get(i); + assertTrue("Array is not sorted.", prev <= next); + prev = next; + } + } +} diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/IntegerArrayTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/IntegerArrayTest.java new file mode 100644 index 00000000..a3949206 --- /dev/null +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/IntegerArrayTest.java @@ -0,0 +1,65 @@ +package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.util.Random; + +import org.junit.Test; + +/** + * Unit test for this arraylist of primitive ints. + * + * @author Erich Schubert + * @since 0.7.1 + */ +public class IntegerArrayTest { + @Test + public void basicTest() { + IntegerArray arr = new IntegerArray(11); + assertTrue("Allocation does not match.", arr.data.length == 11); + assertTrue("Initial size is not empty.", arr.size() == 0); + + Random r = new Random(0L); + for(int i = 0; i < 11; i++) { + arr.add(r.nextInt()); + } + assertTrue("Array is not full.", arr.data.length == arr.size()); + arr.add(r.nextInt()); + assertEquals("Allocation does not match after resize.", 17, arr.data.length); + for(int i = 0; i < 81; i++) { + arr.add(r.nextInt()); + } + assertEquals("Array does not have expected size.", 11 + 1 + 81, arr.size()); + arr.sort(); + assertEquals("Allocation does not match after resize.", 139, arr.data.length); + int prev = arr.get(0); + for(int i = 1; i < arr.size(); i++) { + int next = arr.get(i); + assertTrue("Array is not sorted.", prev <= next); + prev = next; + } + } +} diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/TestDoubleIntegerArrayQuickSort.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/DoubleIntegerArrayQuickSortTest.java index 4db9b371..043e91dc 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/TestDoubleIntegerArrayQuickSort.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/DoubleIntegerArrayQuickSortTest.java @@ -35,8 +35,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Test the integer array (index array) quick sort. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestDoubleIntegerArrayQuickSort implements JUnit4Test { +public class DoubleIntegerArrayQuickSortTest implements JUnit4Test { /** * Array size to use. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/TestIntegerArrayQuickSort.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/IntegerArrayQuickSortTest.java index f6dce701..0e5ee922 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/TestIntegerArrayQuickSort.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/IntegerArrayQuickSortTest.java @@ -35,8 +35,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Test the integer array (index array) quick sort. * * @author Erich Schubert + * @since 0.7.0 */ -public class TestIntegerArrayQuickSort implements JUnit4Test { +public class IntegerArrayQuickSortTest implements JUnit4Test { /** * Array size to use. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestDoubleHeap.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleHeapTest.java index 4e147faf..50fd4176 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestDoubleHeap.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleHeapTest.java @@ -35,8 +35,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Perform standard unit tests on the double-indexed heap structures. * * @author Erich Schubert + * @since 0.5.5 */ -public class TestDoubleHeap implements JUnit4Test { +public class DoubleHeapTest implements JUnit4Test { @Test public void testDoubleMinHeap() { Random r = new Random(); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestDoubleObjectHeaps.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectHeapsTest.java index 31d3d7a5..03b069be 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestDoubleObjectHeaps.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectHeapsTest.java @@ -35,8 +35,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * Perform standard unit tests on the double-object heap structures. * * @author Erich Schubert + * @since 0.5.5 */ -public class TestDoubleObjectHeaps implements JUnit4Test { +public class DoubleObjectHeapsTest implements JUnit4Test { @Test public void testDoubleObjMinHeap() { Random r = new Random(); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestHeapPerformance.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/HeapPerformanceTest.java index 554e61b5..87a61b39 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestHeapPerformance.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/HeapPerformanceTest.java @@ -33,23 +33,26 @@ import java.util.PriorityQueue; import java.util.Queue; import java.util.Random; +import org.junit.Ignore; import org.junit.Test; /** * Unit test to ensure that our heap is not significantly worse than SUN javas * regular PriorityQueue. - * + * * @author Erich Schubert + * @since 0.5.0 */ -public class TestHeapPerformance { +public class HeapPerformanceTest { final private int queueSize = 200000; final private int preiterations = 20; - + final private int iterations = 200; final private long seed = 123456L; + @Ignore @Test public void testRuntime() throws Exception { // prepare the data set @@ -93,8 +96,8 @@ public class TestHeapPerformance { long htime = System.nanoTime() - hstart; System.err.println("Heap performance test: us: " + htime*1E-9 + " java: " + pqtime*1E-9); - assertTrue("Heap performance regression - run test individually, since the hotspot optimizations may make the difference! " + htime + " >>= " + pqtime, htime < 1.05 * pqtime); - // 1.05 allows some difference in measuring + assertTrue("Heap performance regression - run test individually, since the hotspot optimizations may make the difference! " + htime + " >>= " + pqtime, htime < 1.1 * pqtime); + // 1.1 allows some difference in measuring, which can occur e.g. due to Jacoco instrumentation } private void testHeap(final List<Integer> elements, ComparableMinHeap<Integer> pq) { diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestHeap.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/HeapTest.java index f28750eb..40ab27c4 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestHeap.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/HeapTest.java @@ -34,8 +34,9 @@ import org.junit.Test; * Test the in-memory heap class. * * @author Erich Schubert + * @since 0.5.0 */ -public class TestHeap { +public class HeapTest { /** * Puts 10 integers into both an ascending and a descending heap and verifies * they come out in sequence. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestIntegerHeap.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerHeapTest.java index e5038142..3d24a247 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestIntegerHeap.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerHeapTest.java @@ -34,8 +34,9 @@ import org.junit.Test; * Test the in-memory heap class. * * @author Erich Schubert + * @since 0.5.0 */ -public class TestIntegerHeap { +public class IntegerHeapTest { /** * Puts 10 integers into both an ascending and a descending heap and verifies * they come out in sequence. diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestIntegerMinHeapPerformance.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerMinHeapPerformanceTest.java index 49a37330..89f21a2c 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestIntegerMinHeapPerformance.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerMinHeapPerformanceTest.java @@ -40,8 +40,9 @@ import org.junit.Test; * regular PriorityQueue. * * @author Erich Schubert + * @since 0.5.0 */ -public class TestIntegerMinHeapPerformance { +public class IntegerMinHeapPerformanceTest { final private int queueSize = 100000; final private int iterations = 20; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestTiedTopBoundedHeap.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedHeapTest.java index cab43e6e..7058e111 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestTiedTopBoundedHeap.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedHeapTest.java @@ -36,8 +36,9 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.TiedTopBoundedHeap; * Test the in-memory bounded heap class. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestTiedTopBoundedHeap { +public class TiedTopBoundedHeapTest { /** * Test bounded heap */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestTiedTopBoundedUpdatableHeap.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedUpdatableHeapTest.java index 9b6a48d8..d1de52d6 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestTiedTopBoundedUpdatableHeap.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedUpdatableHeapTest.java @@ -34,7 +34,13 @@ import org.junit.Test; import de.lmu.ifi.dbs.elki.JUnit4Test; -public class TestTiedTopBoundedUpdatableHeap implements JUnit4Test { +/** + * Test the specialized heap structures. + * + * @author Erich Schubert + * @since 0.5.0 + */ +public class TiedTopBoundedUpdatableHeapTest implements JUnit4Test { @Test public void testTiedTopBoundedUpdatableHeap() { final int iters = 100; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestTopBoundedHeap.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TopBoundedHeapTest.java index 73271e44..c2305bcf 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestTopBoundedHeap.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TopBoundedHeapTest.java @@ -36,8 +36,9 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.TopBoundedHeap; * Test the in-memory bounded heap class. * * @author Erich Schubert + * @since 0.4.0 */ -public class TestTopBoundedHeap { +public class TopBoundedHeapTest { /** * Test bounded heap */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestUpdatableHeap.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/UpdatableHeapTest.java index f1a68171..1c449781 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TestUpdatableHeap.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/UpdatableHeapTest.java @@ -33,7 +33,13 @@ import org.junit.Test; import de.lmu.ifi.dbs.elki.JUnit4Test; -public class TestUpdatableHeap implements JUnit4Test { +/** + * Test the updateable heap used by OPTICS. + * + * @author Erich Schubert + * @since 0.5.0 + */ +public class UpdatableHeapTest implements JUnit4Test { @Test public void testUpdatableHeap() { final int iters = 100; diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/TestHashMapHierarchy.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/HashMapHierarchyTest.java index 1f4beb40..ec273988 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/TestHashMapHierarchy.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/HashMapHierarchyTest.java @@ -38,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.hierarchy.Hierarchy.Iter; * Test the main hierarchy implementation. * * @author Erich Schubert + * @since 0.6.0 */ -public class TestHashMapHierarchy implements JUnit4Test { +public class HashMapHierarchyTest implements JUnit4Test { @Test public void testEmpty() { HashMapHierarchy<Object> hier = new HashMapHierarchy<>(); diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/TestDoubleHistogram.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleHistogramTest.java index 8830fd9b..f558acaa 100755 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/TestDoubleHistogram.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleHistogramTest.java @@ -34,8 +34,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * JUnit test to test the {@link ReplacingHistogram} class. * * @author Erich Schubert + * @since 0.2 */ -public class TestDoubleHistogram implements JUnit4Test { +public class DoubleHistogramTest implements JUnit4Test { /** * Test that adds some data to the histogram and compares results. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/TestFlexiHistogram.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FlexiHistogramTest.java index 3410ce69..b40413fd 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/TestFlexiHistogram.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FlexiHistogramTest.java @@ -36,8 +36,9 @@ import de.lmu.ifi.dbs.elki.JUnit4Test; * JUnit test to test the {@link AbstractObjDynamicHistogram} class. * * @author Erich Schubert + * @since 0.5.5 */ -public class TestFlexiHistogram implements JUnit4Test { +public class FlexiHistogramTest implements JUnit4Test { /** * Test that adds some data to the histogram and compares results. */ diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionRangeDBIDsTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionRangeDBIDsTest.java index 242752a0..3405bbf6 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionRangeDBIDsTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionRangeDBIDsTest.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; * * @author Evgeniy Faerman * @author Erich Schubert + * @since 0.7.0 */ public class WeightedQuickUnionRangeDBIDsTest { @Test diff --git a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionStaticDBIDsTest.java b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionStaticDBIDsTest.java index d1778f6a..d2cb370f 100644 --- a/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionStaticDBIDsTest.java +++ b/elki/src/test/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionStaticDBIDsTest.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; * * @author Evgeniy Faerman * @author Erich Schubert + * @since 0.7.0 */ public class WeightedQuickUnionStaticDBIDsTest { @Test |