Index: cpp/frams/_demos/paramtree_paramlist_test.cpp
===================================================================
--- cpp/frams/_demos/paramtree_paramlist_test.cpp	(revision 1035)
+++ cpp/frams/_demos/paramtree_paramlist_test.cpp	(revision 1044)
@@ -11,4 +11,7 @@
 #include <frams/model/geometry/modelgeoclass.h>
 #include <frams/model/modelobj.h>
+#include <frams/model/similarity/measure-distribution.h>
+#include <frams/model/similarity/measure-greedy.h>
+#include <frams/model/similarity/measure-hungarian.h>
 #include "genotypeloader.h"
 #include "paramtree_print.h"
@@ -27,4 +30,7 @@
 	NeuroNetConfig nn_config(&neurofac);
 	ModelGeometry modelgeo;
+	SimilMeasureDistribution simil_measure_distr;
+	SimilMeasureGreedy simil_measure_greedy;
+	SimilMeasureHungarian simil_measure_hungarian;
 
 	MutableParamList combined;
@@ -39,4 +45,7 @@
 	combined += &nn_config.par;
 	combined += &modelgeo.par;
+	combined += &simil_measure_distr.localpar;
+	combined += &simil_measure_greedy.localpar;
+	combined += &simil_measure_hungarian.localpar;
 
 	ParamTree tree(&combined);
Index: cpp/frams/_demos/simil_test.cpp
===================================================================
--- cpp/frams/_demos/simil_test.cpp	(revision 1035)
+++ cpp/frams/_demos/simil_test.cpp	(revision 1044)
@@ -5,11 +5,37 @@
 
 #include <vector>
+#include <string>
 #include "common/loggers/loggertostdout.h"
 #include "frams/_demos/genotypeloader.h"
 #include "frams/genetics/preconfigured.h"
 #include "common/virtfile/stdiofile.h"
-#include "frams/model/similarity/simil_model.h"
-
-
+#include "frams/model/similarity/measure-distribution.h"
+#include "frams/model/similarity/measure-greedy.h"
+#include "frams/model/similarity/measure-hungarian.h"
+
+using namespace std;
+
+int add_double_param(std::vector<string> *args, int pos, std::vector<double> *params, std::vector<string> *params_names)
+{
+    for (unsigned int i = 0; i < params_names->size(); i++)
+    {
+        try
+        {
+            params->push_back(std::stod(args->at(pos)));
+            pos++;
+        }
+        catch (const std::invalid_argument&)
+        {
+            printf("%s should be a number\n", params_names->at(i).c_str());
+            return -1;
+        }
+        catch (const std::out_of_range&)
+        {
+            printf("%s should be inside double range\n", params_names->at(i).c_str());
+            return -1;
+        }
+    }
+    return 0;
+}
 
 /** Computes a matrix of distances between all genotypes in the specified
@@ -18,206 +44,181 @@
 int main(int argc, char *argv[])
 {
-	LoggerToStdout messages_to_stdout(LoggerBase::Enable);
-	int iCurrParam = 0; // index of the currently processed parameter
-	char *szCurrParam = NULL;
-	ModelSimil M; // similarity computing object
-	bool bPrintNames = false; // specifies if names of genotypes are to be printed
-	int nResult = 0; // a temporary result
-
-	if (argc < 8)
-	{
-		printf("Too few parameters!\n");
-		printf("Command line: [-names] <genotypesFile> <measure> <w_dP> <w_dDEG> <w_dNEU> <w_dGEO> <fixZaxis?>\n\n");
-
-		printf("Parameters:\n");
-		printf("  <genotypesFile> name of a file with genotypes\n");
-		printf("  <measure> similarity measure\n");
-		printf("  <w_dP> weight of the difference in the number of parts\n");
-		printf("  <w_dDEG> weight of the difference in degrees of matched parts\n");
-		printf("  <w_dNEU> weight of the difference in neurons of matched parts\n");
-		printf("  <w_dGEO> weight of the distance of matched parts\n");
-		printf("  <fixZaxis?> should the 'z' (vertical) coordinate be fixed during the alignment? (0 or 1)\n\n");
-
-		printf("Switches:\n");
-		printf("  -names specifies that the number and names of genotypes are to be printed to output\n");
-		printf("  before the distance matrix; by default the number and names are not printed\n\n");
-
-		printf("Outputs a symmetric distance matrix in the format:\n");
-		printf("  <row_1> (columns in a row are separated by TABs)\n");
-		printf("  ...\n");
-		printf("  <row_n>\n");
-
-		return -1;
-	}
-
-	// prepare output parameters from .gen file
-	vector<Geno *> pvGenos;
-	vector<char *> pvNames;
-
-	// check if there is a switch
-	iCurrParam = 1;
-	szCurrParam = argv[iCurrParam];
-	if (strcmp(szCurrParam, "-names") == 0)
-	{
-		// switch "-names" was given; print names also
-		bPrintNames = true;
-		// pass to the next parameter
-		iCurrParam++;
-	}
-
-	// check the parameters
-	// get <genotypesFile> name from command line
-	char *szFileName = argv[iCurrParam];
-
-	// initially set measure components' weights to invalid values (negative)
-	for (int i = 0; i < M.GetNOFactors(); i++)
-	{
-		M.m_adFactors[i] = -1.0;
-	}
-
-	iCurrParam++;
-	szCurrParam = argv[iCurrParam];
-	int measure_type = -1;
-	nResult = sscanf(szCurrParam, "%d", &measure_type);
-	if (nResult != 1)
-	{
-		printf("Measure type should be a number!\n");
-		return -1;
-	}
-
-	if (measure_type != 0 && measure_type != 1)
-	{
-		printf("Measure type should be 0 (flexible criteria order and optimal matching) or 1 (vertex degree order and greedy matching)!\n");
-		return -1;
-	}
-
-	M.matching_method = measure_type;
-
-	const char *params[] = { "<w_dP>", "<w_dDEG>", "<w_dNEU>", "<w_dGEO>" };
-	for (int i = 0; i < M.GetNOFactors(); i++)
-	{
-		iCurrParam++;
-		szCurrParam = argv[iCurrParam];
-		nResult = sscanf(szCurrParam, "%lf", &M.m_adFactors[i]);
-		if (nResult != 1)
-		{
-			// <w_dX> is not a number -- error
-			printf("%s", params[i]);
-			printf(" should be a number\n");
-			return -1;
-		}
-		else
-		{
-			// <w_dX> is a number; check if nonnegative
-			if (M.m_adFactors[i] < 0.0)
-			{
-				printf("%s", params[i]);
-				printf(" should be a nonnegative number\n");
-				return -1;
-			}
-		}
-	}
-
-	iCurrParam++;
-	szCurrParam = argv[iCurrParam];
-	nResult = sscanf(szCurrParam, "%d", &M.fixedZaxis);
-	if (nResult != 1)
-	{
-		// <isZFixed> is not a number -- error
-		printf("<isZFixed> should be a number\n");
-		return -1;
-	}
-	else if (M.fixedZaxis != 0 && M.fixedZaxis != 1)
-	{
-		printf("<isZFixed>=%d. <isZFixed> should be equal to 0 or 1\n", M.fixedZaxis);
-		return -1;
-	}
-
-	// read the input file
-	// prepare loading of genotypes from a .gen file
-	// create some basic genotype converters
-	PreconfiguredGenetics genetics;
-	StdioFileSystem_autoselect stdiofilesys;
-
-	long count = 0, totalsize = 0;
-	GenotypeMiniLoader loader(szFileName);
-	GenotypeMini *loaded;
-	while (loaded = loader.loadNextGenotype())
-	{
-		// while a valid genotype was loaded
-		count++;
-		totalsize += loaded->genotype.length();
-		// create a Geno object based on the MiniGenotype
-		Geno *pNextGenotype = new Geno(loaded->genotype);
-		if ((pNextGenotype != NULL) && (pNextGenotype->isValid()))
-		{
-			pvGenos.push_back(pNextGenotype);
-			char *szNewName = new char[loaded->name.length() + 1];
-			strcpy(szNewName, loaded->name.c_str());
-			pvNames.push_back(szNewName);
-		}
-		else
-		{
-			printf("Genotype %2li is not valid\n", count);
-			if (pNextGenotype != NULL) delete pNextGenotype;
-		}
-	}
-	if (loader.getStatus() == GenotypeMiniLoader::OnError)
-	{
-		printf("Error: %s", loader.getError().c_str());
-	}
-
-	double dSimilarity = 0.0;
-	double **aaSimil = NULL; // array of similarities
-
-	// create an empty array of similarities
-	aaSimil = new double*[pvGenos.size()];
-	for (unsigned int k = 0; k < pvGenos.size(); k++)
-	{
-		aaSimil[k] = new double[pvGenos.size()];
-		for (unsigned int l = 0; l < pvGenos.size(); l++)
-			aaSimil[k][l] = 0.0;
-	}
-
-	// compute and store similarities
-	for (unsigned int i = 0; i < pvGenos.size(); i++)
-	{
-		for (unsigned int j = 0; j < pvGenos.size(); j++)
-		{
-			dSimilarity = M.EvaluateDistance(pvGenos.operator[](i), pvGenos.operator[](j));
-			aaSimil[i][j] = dSimilarity;
-		}
-	}
-
-	if (bPrintNames)
-	{
-		// if the "-names" switch was given, print the number of genotypes and their names
-		printf("%li\n", pvGenos.size());
-		for (unsigned int iGen = 0; iGen < pvNames.size(); iGen++)
-		{
-			printf("%s\n", pvNames.at(iGen));
-		}
-	}
-
-	// print out the matrix of similarities
-	for (unsigned int i = 0; i < pvGenos.size(); i++)
-	{
-		for (unsigned int j = 0; j < pvGenos.size(); j++)
-		{
-			printf("%.2lf\t", aaSimil[i][j]);
-		}
-		printf("\n");
-	}
-
-	// delete vectors and arrays
-	for (unsigned int i = 0; i < pvGenos.size(); i++)
-	{
-		delete pvGenos.operator[](i);
-		delete[] pvNames.operator[](i);
-		delete[] aaSimil[i];
-	}
-
-	delete[] aaSimil;
-
-	return 0;
+    typedef double *pDouble;
+    LoggerToStdout messages_to_stdout(LoggerBase::Enable);
+    SimilMeasure *simil_measure = nullptr;
+    if (argc < 5)
+    {
+        printf("Too few parameters!\n");
+        printf("Command line: [-names] <genotypesFile> <measure (greedy/hungarian)> <w_dP> <w_dDEG> <w_dNEU> <w_dGEO> <fixZaxis?>\n\n");
+        printf("Command line: [-names] <genotypesFile> <measure (distribution)> <desc> <simil> <dens> <bins> <samp_num>\n\n");
+        printf("Parameters:\n");
+        printf("  <genotypesFile> name of a file with genotypes\n");
+        printf("  <measure> similarity measure name (greedy/hungarian/distribution)\n");
+        printf("\n");
+        printf("Parameters of greedy and hungarian measures:\n");
+        printf("  <w_dP> weight of the difference in the number of parts\n");
+        printf("  <w_dDEG> weight of the difference in degrees of matched parts\n");
+        printf("  <w_dNEU> weight of the difference in neurons of matched parts\n");
+        printf("  <w_dGEO> weight of the distance of matched parts\n");
+        printf("  <fixZaxis?> should the 'z' (vertical) coordinate be fixed during the alignment? (0 or 1)\n\n");
+        printf("Parameters of distribution measure:\n");
+        printf("  <dens> sampling density\n");
+        printf("  <bins> number of histogram bins\n");
+        printf("  <samp_num> number of samples taken\n\n");
+
+        printf("Switches:\n");
+        printf("  -names specifies that the number and names of genotypes are to be printed to output\n");
+        printf("  before the distance matrix; by default the number and names are not printed\n\n");
+
+        printf("Outputs a symmetric distance matrix in the format:\n");
+        printf("  <row_1> (columns in a row are separated by TABs)\n");
+        printf("  ...\n");
+        printf("  <row_n>\n");
+
+        return -1;
+    }
+
+    std::vector<string> args;
+    for (int i = 1; i < argc; i++)
+        args.push_back(std::string(argv[i]));
+
+    bool print_names = false;
+
+    int pos = 1;
+    if (args.at(0).compare("-names")==0)
+    {
+        print_names = true;
+        pos = 2;
+    }
+
+    string measure_name = args.at(pos);
+    pos++;
+    std::vector<double> params;
+
+    if (measure_name.compare("greedy")==0 || measure_name.compare("hungarian")==0)
+    {
+        std::vector<string> params_names{ "<w_dP>", "<w_dDEG>", "<w_dNEU>", "<w_dGEO>",  "<fixZaxis?>" };
+
+        if (add_double_param(&args, pos, &params, &params_names) == -1)
+            return -1;
+
+        if (measure_name.compare("greedy")==0)
+            simil_measure = new SimilMeasureGreedy();
+        else
+            simil_measure = new SimilMeasureHungarian();
+    }
+
+
+    else if (measure_name.compare("distribution")==0)
+    {
+        std::vector<string> params_names{ "<dens>", "<bins>", "<samp_num>" };
+
+        if (add_double_param(&args, pos, &params, &params_names)==-1)
+            return -1;
+
+        simil_measure = new SimilMeasureDistribution();
+    }
+
+    else
+    {
+        printf("Measure type should be greedy (flexible criteria order and optimal matching), hungarian (vertex degree order and greedy matching) or distribution!\n");
+        return -1;
+    }
+
+    simil_measure->setParams(params);
+
+    // read the input file
+    // prepare loading of genotypes from a .gen file
+    // create some basic genotype converters
+    PreconfiguredGenetics genetics;
+    StdioFileSystem_autoselect stdiofilesys;
+
+    // prepare output parameters from .gen file
+    vector<Geno *> pvGenos;
+    vector<char *> pvNames;
+
+    long count = 0, totalsize = 0;
+    GenotypeMiniLoader loader(args.at(0).c_str());
+    GenotypeMini *loaded;
+    while (loaded = loader.loadNextGenotype())
+    {
+        // while a valid genotype was loaded
+        count++;
+        totalsize += loaded->genotype.length();
+        // create a Geno object based on the MiniGenotype
+        Geno *pNextGenotype = new Geno(loaded->genotype);
+        if ((pNextGenotype != NULL) && (pNextGenotype->isValid()))
+        {
+            pvGenos.push_back(pNextGenotype);
+            char *szNewName = new char[loaded->name.length() + 1];
+            strcpy(szNewName, loaded->name.c_str());
+            pvNames.push_back(szNewName);
+        }
+        else
+        {
+            printf("Genotype %2li is not valid\n", count);
+            if (pNextGenotype != NULL) delete pNextGenotype;
+        }
+    }
+    if (loader.getStatus() == GenotypeMiniLoader::OnError)
+    {
+        printf("Error: %s", loader.getError().c_str());
+    }
+
+    double dSimilarity = 0.0;
+    double **aaSimil = NULL; // array of similarities
+
+    // create the empty array of similarities
+    aaSimil = new pDouble[pvGenos.size()];
+    for (unsigned int k = 0; k < pvGenos.size(); k++)
+    {
+        aaSimil[k] = new double[pvGenos.size()];
+        for (unsigned int l = 0; l < pvGenos.size(); l++)
+            aaSimil[k][l] = 0.0;
+    }
+
+
+
+    // compute and remember similarities
+    for (unsigned int i = 0; i < pvGenos.size(); i++)
+    {
+        for (unsigned int j = 0; j < pvGenos.size(); j++)
+        {
+            dSimilarity = simil_measure->evaluateDistance(pvGenos.operator[](i), pvGenos.operator[](j));
+            aaSimil[i][j] = dSimilarity;
+        }
+    }
+
+    if (print_names)
+    {
+        // if "-names" switch was given, print the number of genotypes and their names
+        printf("%li\n", pvGenos.size());
+        for (unsigned int iGen = 0; iGen < pvNames.size(); iGen++)
+        {
+            printf("%s\n", pvNames.at(iGen));
+        }
+    }
+
+    // print out the matrix of similarities
+    for (unsigned int i = 0; i < pvGenos.size(); i++)
+    {
+        for (unsigned int j = 0; j < pvGenos.size(); j++)
+        {
+            printf("%.2lf\t", aaSimil[i][j]);
+        }
+        printf("\n");
+    }
+
+    // delete vectors and arrays
+    for (unsigned int i = 0; i < pvGenos.size(); i++)
+    {
+        delete pvGenos.operator[](i);
+        delete[] pvNames.operator[](i);
+        delete[] aaSimil[i];
+    }
+
+    delete[] aaSimil;
+    delete simil_measure;
+
+    return 0;
 }
Index: cpp/frams/_demos/simil_unittests.cpp
===================================================================
--- cpp/frams/_demos/simil_unittests.cpp	(revision 1035)
+++ cpp/frams/_demos/simil_unittests.cpp	(revision 1044)
@@ -3,5 +3,5 @@
 // See LICENSE.txt for details.
 
-#include "frams/model/similarity/simil_match.h"
+#include "frams/model/similarity/simil-match.h"
 
 /** Runs unit tests of classes used in computation of similarity.
@@ -42,10 +42,10 @@
         for (i = 0; i < nSize1; i++)
         {
-            assert(match1.IsMatched(j, i) == false);
+            assert(match1.isMatched(j, i) == false);
         }
     }
 
     // test if all are unmatched - new method
-    assert(match1.IsEmpty() == true);
+    assert(match1.isEmpty() == true);
 
     // check assymetric matching
@@ -55,14 +55,14 @@
     for (i = 0; i < nSize1; i++)
     {
-        assert(match2.IsMatched(0, i) == false);
+        assert(match2.isMatched(0, i) == false);
     }
     // check if all elements are unmatched yet in object 1
     for (i = 0; i < nSize2; i++)
     {
-        assert(match2.IsMatched(1, i) == false);
+        assert(match2.isMatched(1, i) == false);
     }
 
     // test if all are unmatched - new method
-    assert(match2.IsEmpty() == true);
+    assert(match2.isEmpty() == true);
 
     return 0;
@@ -89,6 +89,6 @@
 
             // check size of both objects
-            assert(pMatching->GetObjectSize(0) == i);
-            assert(pMatching->GetObjectSize(1) == j);
+            assert(pMatching->getObjectSize(0) == i);
+            assert(pMatching->getObjectSize(1) == j);
 
             // delete disused object
@@ -114,20 +114,20 @@
         SimilMatching Source(iSize, iSize);
         // check if it is empty
-        assert(Source.IsEmpty() == true);
+        assert(Source.isEmpty() == true);
         // check sizes of objects
-        assert(Source.GetObjectSize(0) == iSize);
-        assert(Source.GetObjectSize(1) == iSize);
+        assert(Source.getObjectSize(0) == iSize);
+        assert(Source.getObjectSize(1) == iSize);
         // create a copy of this matching
         SimilMatching Dest(Source);
         // check the copy:
         // - sizes of matched object
-        assert(Dest.GetObjectSize(0) == Source.GetObjectSize(0));
-        assert(Dest.GetObjectSize(1) == Source.GetObjectSize(1));
+        assert(Dest.getObjectSize(0) == Source.getObjectSize(0));
+        assert(Dest.getObjectSize(1) == Source.getObjectSize(1));
         // - the copy should be empty, too
-        assert(Dest.IsEmpty() == true);
+        assert(Dest.isEmpty() == true);
         // make it empty once again
-        Dest.Empty();
+        Dest.empty();
         // and check once more
-        assert(Dest.IsEmpty() == true);
+        assert(Dest.isEmpty() == true);
     }
 
@@ -136,23 +136,23 @@
         SimilMatching Source(iSize, iSize);
         // check if it is empty
-        assert(Source.IsEmpty() == true);
+        assert(Source.isEmpty() == true);
         // check sizes of objects
-        assert(Source.GetObjectSize(0) == iSize);
-        assert(Source.GetObjectSize(1) == iSize);
+        assert(Source.getObjectSize(0) == iSize);
+        assert(Source.getObjectSize(1) == iSize);
         // match objects (iObj, iObj)
         for (iObj = 0; iObj < iSize; iObj++)
         {
-            Source.Match(0, iObj, 1, iObj);
+            Source.match(0, iObj, 1, iObj);
         }
         // check if the matching is full
-        assert(Source.IsFull() == true);
+        assert(Source.isFull() == true);
         // now create a copy of the matching
         SimilMatching Dest(Source);
         // check the copy
         // - sizes of matched object
-        assert(Dest.GetObjectSize(0) == Source.GetObjectSize(0));
-        assert(Dest.GetObjectSize(1) == Source.GetObjectSize(1));
+        assert(Dest.getObjectSize(0) == Source.getObjectSize(0));
+        assert(Dest.getObjectSize(1) == Source.getObjectSize(1));
         // - the copy should be full, too
-        assert(Dest.IsFull() == true);
+        assert(Dest.isFull() == true);
         // - the copy should have exactly the same assignments in matching
         for (iObj = 0; iObj < iSize; iObj++)
@@ -160,14 +160,14 @@
             // all object should be matched!
             // check both directions: 0 -> 1
-            assert(Dest.IsMatched(0, iObj) == true);
-            assert(iObj == Dest.GetMatchedIndex(0, iObj));
+            assert(Dest.isMatched(0, iObj) == true);
+            assert(iObj == Dest.getMatchedIndex(0, iObj));
             // and: 1 -> 0
-            assert(Dest.IsMatched(1, iObj) == true);
-            assert(iObj == Dest.GetMatchedIndex(1, iObj));
+            assert(Dest.isMatched(1, iObj) == true);
+            assert(iObj == Dest.getMatchedIndex(1, iObj));
         }
         // make it empty
-        Dest.Empty();
+        Dest.empty();
         // and check once more
-        assert(Dest.IsEmpty() == true);
+        assert(Dest.isEmpty() == true);
     }
 
@@ -176,23 +176,23 @@
         SimilMatching Source(iSize, iSize);
         // check if it is empty
-        assert(Source.IsEmpty() == true);
+        assert(Source.isEmpty() == true);
         // check sizes of objects
-        assert(Source.GetObjectSize(0) == iSize);
-        assert(Source.GetObjectSize(1) == iSize);
+        assert(Source.getObjectSize(0) == iSize);
+        assert(Source.getObjectSize(1) == iSize);
         // match objects (iObj, N - iObj - 1)
         for (iObj = 0; iObj < iSize; iObj++)
         {
-            Source.Match(0, iObj, 1, iSize - iObj - 1);
+            Source.match(0, iObj, 1, iSize - iObj - 1);
         }
         // check if the matching is full
-        assert(Source.IsFull() == true);
+        assert(Source.isFull() == true);
         // now create a copy of the matching
         SimilMatching Dest(Source);
         // check the copy
         // - sizes of matched object
-        assert(Dest.GetObjectSize(0) == Source.GetObjectSize(0));
-        assert(Dest.GetObjectSize(1) == Source.GetObjectSize(1));
+        assert(Dest.getObjectSize(0) == Source.getObjectSize(0));
+        assert(Dest.getObjectSize(1) == Source.getObjectSize(1));
         // - the copy should be full, too
-        assert(Dest.IsFull() == true);
+        assert(Dest.isFull() == true);
         // - the copy should have exactly the same assignments in matching
         for (iObj = 0; iObj < iSize; iObj++)
@@ -200,14 +200,14 @@
             // all object should be matched!
             // check both directions: 0 -> 1
-            assert(Dest.IsMatched(0, iObj) == true);
-            assert((iSize - iObj - 1) == Dest.GetMatchedIndex(0, iObj));
+            assert(Dest.isMatched(0, iObj) == true);
+            assert((iSize - iObj - 1) == Dest.getMatchedIndex(0, iObj));
             // and: 1 -> 0
-            assert(Dest.IsMatched(1, iObj) == true);
-            assert((iSize - iObj - 1) == Dest.GetMatchedIndex(1, iObj));
+            assert(Dest.isMatched(1, iObj) == true);
+            assert((iSize - iObj - 1) == Dest.getMatchedIndex(1, iObj));
         }
         // make it empty
-        Dest.Empty();
+        Dest.empty();
         // and check once more
-        assert(Dest.IsEmpty() == true);
+        assert(Dest.isEmpty() == true);
     }
 
@@ -216,23 +216,23 @@
         SimilMatching Source(iSize, 2 * iSize);
         // check if it is empty
-        assert(Source.IsEmpty() == true);
+        assert(Source.isEmpty() == true);
         // check sizes of objects
-        assert(Source.GetObjectSize(0) == iSize);
-        assert(Source.GetObjectSize(1) == 2 * iSize);
+        assert(Source.getObjectSize(0) == iSize);
+        assert(Source.getObjectSize(1) == 2 * iSize);
         // match objects (iObj, 2 * iObj)
         for (iObj = 0; iObj < iSize; iObj++)
         {
-            Source.Match(0, iObj, 1, 2 * iObj);
+            Source.match(0, iObj, 1, 2 * iObj);
         }
         // check if the matching is full (should be, as the smaller set is completely matched
-        assert(Source.IsFull() == true);
+        assert(Source.isFull() == true);
         // now create a copy of the matching
         SimilMatching Dest(Source);
         // check the copy
         // - sizes of matched object
-        assert(Dest.GetObjectSize(0) == Source.GetObjectSize(0));
-        assert(Dest.GetObjectSize(1) == Source.GetObjectSize(1));
+        assert(Dest.getObjectSize(0) == Source.getObjectSize(0));
+        assert(Dest.getObjectSize(1) == Source.getObjectSize(1));
         // - the copy should be full, too
-        assert(Dest.IsFull() == true);
+        assert(Dest.isFull() == true);
         // - the copy should have exactly the same assignments in matching
         for (iObj = 0; iObj < iSize; iObj++)
@@ -240,18 +240,18 @@
             // check both directions: 0 -> 1
             // (all matched, (iObj, 2 * iObj))
-            assert(Dest.IsMatched(0, iObj) == true);
-            assert((2 * iObj) == Dest.GetMatchedIndex(0, iObj));
+            assert(Dest.isMatched(0, iObj) == true);
+            assert((2 * iObj) == Dest.getMatchedIndex(0, iObj));
             // and direction; 1 -> 0
             // (only even are matched, ( 2 * iObj, iObj))
             // for 2 * iObj (which are even): matched
-            assert(Dest.IsMatched(1, 2 * iObj) == true);
-            assert(iObj == Dest.GetMatchedIndex(1, 2 * iObj));
+            assert(Dest.isMatched(1, 2 * iObj) == true);
+            assert(iObj == Dest.getMatchedIndex(1, 2 * iObj));
             // for 2 * iObj + 1 (which are odd): unmatched
-            assert(Dest.IsMatched(1, 2 * iObj + 1) == false);
+            assert(Dest.isMatched(1, 2 * iObj + 1) == false);
         }
         // make it empty
-        Dest.Empty();
+        Dest.empty();
         // and check once more
-        assert(Dest.IsEmpty() == true);
+        assert(Dest.isEmpty() == true);
     }
 
@@ -273,5 +273,5 @@
 
     // matching is empty
-    assert(match1.IsEmpty() == true);
+    assert(match1.isEmpty() == true);
 
     // create matching - (i,i)
@@ -280,27 +280,27 @@
 
         // matching is not full
-        assert(match1.IsFull() == false);
+        assert(match1.isFull() == false);
 
         // these are not matched yet
-        assert(match1.IsMatched(0, i) == false);
-        assert(match1.IsMatched(1, i) == false);
+        assert(match1.isMatched(0, i) == false);
+        assert(match1.isMatched(1, i) == false);
 
         // now - match!
-        match1.Match(0, i, 1, i);
+        match1.match(0, i, 1, i);
 
         // matching is not empty
-        assert(match1.IsEmpty() == false);
+        assert(match1.isEmpty() == false);
 
         // now they are matched
-        assert(match1.IsMatched(0, i) == true);
-        assert(match1.IsMatched(1, i) == true);
+        assert(match1.isMatched(0, i) == true);
+        assert(match1.isMatched(1, i) == true);
 
         // check the matched index for object 0 and 1
-        assert(match1.GetMatchedIndex(0, i) == i);
-        assert(match1.GetMatchedIndex(1, i) == i);
+        assert(match1.getMatchedIndex(0, i) == i);
+        assert(match1.getMatchedIndex(1, i) == i);
     }
 
     // now matching have to be full
-    assert(match1.IsFull() == true);
+    assert(match1.isFull() == true);
 
     // check some symmetric matching
@@ -308,5 +308,5 @@
 
     // matching is empty
-    assert(match2.IsEmpty() == true);
+    assert(match2.isEmpty() == true);
 
     // create matching - (i, nSize1 - 1 - i)
@@ -315,27 +315,27 @@
 
         // matching is not full
-        assert(match2.IsFull() == false);
+        assert(match2.isFull() == false);
 
         // these are not matched yet
-        assert(match2.IsMatched(0, i) == false);
-        assert(match2.IsMatched(1, nSize1 - 1 - i) == false);
+        assert(match2.isMatched(0, i) == false);
+        assert(match2.isMatched(1, nSize1 - 1 - i) == false);
 
         // now - match (but use the opposite syntax)!
-        match2.Match(1, nSize1 - 1 - i, 0, i);
+        match2.match(1, nSize1 - 1 - i, 0, i);
 
         // matching is not empty
-        assert(match2.IsEmpty() == false);
+        assert(match2.isEmpty() == false);
 
         // now they are matched
-        assert(match2.IsMatched(0, i) == true);
-        assert(match2.IsMatched(1, nSize1 - 1 - i) == true);
+        assert(match2.isMatched(0, i) == true);
+        assert(match2.isMatched(1, nSize1 - 1 - i) == true);
 
         // check the matched index for object 0 and 1
-        assert(match2.GetMatchedIndex(0, i) == (nSize1 - 1 - i));
-        assert(match2.GetMatchedIndex(1, nSize1 - 1 - i) == i);
+        assert(match2.getMatchedIndex(0, i) == (nSize1 - 1 - i));
+        assert(match2.getMatchedIndex(1, nSize1 - 1 - i) == i);
     }
 
     // now matching have to be full
-    assert(match2.IsFull() == true);
+    assert(match2.isFull() == true);
 
     // check some asymmnetic matching, too
@@ -343,5 +343,5 @@
 
     // matching is empty
-    assert(match3.IsEmpty() == true);
+    assert(match3.isEmpty() == true);
 
     // create matching - (i, 2 * i)
@@ -350,30 +350,30 @@
 
         // matching is not full
-        assert(match3.IsFull() == false);
+        assert(match3.isFull() == false);
 
         // these are not matched yet
-        assert(match3.IsMatched(0, i) == false);
-        assert(match3.IsMatched(1, 2 * i) == false);
+        assert(match3.isMatched(0, i) == false);
+        assert(match3.isMatched(1, 2 * i) == false);
 
         // now - match (but use the opposite syntax)!
-        match3.Match(1, 2 * i, 0, i);
+        match3.match(1, 2 * i, 0, i);
 
         // matching is not empty
-        assert(match3.IsEmpty() == false);
+        assert(match3.isEmpty() == false);
 
         // now they are matched
-        assert(match3.IsMatched(0, i) == true);
-        assert(match3.IsMatched(1, 2 * i) == true);
+        assert(match3.isMatched(0, i) == true);
+        assert(match3.isMatched(1, 2 * i) == true);
 
         // but the odd elements of object 1 are not matched
-        assert(match3.IsMatched(1, 2 * i + 1) == false);
+        assert(match3.isMatched(1, 2 * i + 1) == false);
 
         // check the matched index for object 0 and 1
-        assert(match3.GetMatchedIndex(0, i) == 2 * i);
-        assert(match3.GetMatchedIndex(1, 2 * i) == i);
+        assert(match3.getMatchedIndex(0, i) == 2 * i);
+        assert(match3.getMatchedIndex(1, 2 * i) == i);
     }
 
     // now matching have to be full (because the smallest object has all elements matched).
-    assert(match3.IsFull() == true);
+    assert(match3.isFull() == true);
 
     return 0;
