Index: cpp/frams/_demos/simil_unittests.cpp
===================================================================
--- cpp/frams/_demos/simil_unittests.cpp	(revision 351)
+++ 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;
