Ignore:
Timestamp:
12/10/20 22:33:22 (3 months ago)
Author:
oriona
Message:

Similarity measures code refactored. Distribution-based similarity measure added.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • cpp/frams/_demos/simil_unittests.cpp

    r351 r1044  
    33// See LICENSE.txt for details.
    44
    5 #include "frams/model/similarity/simil_match.h"
     5#include "frams/model/similarity/simil-match.h"
    66
    77/** Runs unit tests of classes used in computation of similarity.
     
    4242        for (i = 0; i < nSize1; i++)
    4343        {
    44             assert(match1.IsMatched(j, i) == false);
     44            assert(match1.isMatched(j, i) == false);
    4545        }
    4646    }
    4747
    4848    // test if all are unmatched - new method
    49     assert(match1.IsEmpty() == true);
     49    assert(match1.isEmpty() == true);
    5050
    5151    // check assymetric matching
     
    5555    for (i = 0; i < nSize1; i++)
    5656    {
    57         assert(match2.IsMatched(0, i) == false);
     57        assert(match2.isMatched(0, i) == false);
    5858    }
    5959    // check if all elements are unmatched yet in object 1
    6060    for (i = 0; i < nSize2; i++)
    6161    {
    62         assert(match2.IsMatched(1, i) == false);
     62        assert(match2.isMatched(1, i) == false);
    6363    }
    6464
    6565    // test if all are unmatched - new method
    66     assert(match2.IsEmpty() == true);
     66    assert(match2.isEmpty() == true);
    6767
    6868    return 0;
     
    8989
    9090            // check size of both objects
    91             assert(pMatching->GetObjectSize(0) == i);
    92             assert(pMatching->GetObjectSize(1) == j);
     91            assert(pMatching->getObjectSize(0) == i);
     92            assert(pMatching->getObjectSize(1) == j);
    9393
    9494            // delete disused object
     
    114114        SimilMatching Source(iSize, iSize);
    115115        // check if it is empty
    116         assert(Source.IsEmpty() == true);
     116        assert(Source.isEmpty() == true);
    117117        // check sizes of objects
    118         assert(Source.GetObjectSize(0) == iSize);
    119         assert(Source.GetObjectSize(1) == iSize);
     118        assert(Source.getObjectSize(0) == iSize);
     119        assert(Source.getObjectSize(1) == iSize);
    120120        // create a copy of this matching
    121121        SimilMatching Dest(Source);
    122122        // check the copy:
    123123        // - sizes of matched object
    124         assert(Dest.GetObjectSize(0) == Source.GetObjectSize(0));
    125         assert(Dest.GetObjectSize(1) == Source.GetObjectSize(1));
     124        assert(Dest.getObjectSize(0) == Source.getObjectSize(0));
     125        assert(Dest.getObjectSize(1) == Source.getObjectSize(1));
    126126        // - the copy should be empty, too
    127         assert(Dest.IsEmpty() == true);
     127        assert(Dest.isEmpty() == true);
    128128        // make it empty once again
    129         Dest.Empty();
     129        Dest.empty();
    130130        // and check once more
    131         assert(Dest.IsEmpty() == true);
     131        assert(Dest.isEmpty() == true);
    132132    }
    133133
     
    136136        SimilMatching Source(iSize, iSize);
    137137        // check if it is empty
    138         assert(Source.IsEmpty() == true);
     138        assert(Source.isEmpty() == true);
    139139        // check sizes of objects
    140         assert(Source.GetObjectSize(0) == iSize);
    141         assert(Source.GetObjectSize(1) == iSize);
     140        assert(Source.getObjectSize(0) == iSize);
     141        assert(Source.getObjectSize(1) == iSize);
    142142        // match objects (iObj, iObj)
    143143        for (iObj = 0; iObj < iSize; iObj++)
    144144        {
    145             Source.Match(0, iObj, 1, iObj);
     145            Source.match(0, iObj, 1, iObj);
    146146        }
    147147        // check if the matching is full
    148         assert(Source.IsFull() == true);
     148        assert(Source.isFull() == true);
    149149        // now create a copy of the matching
    150150        SimilMatching Dest(Source);
    151151        // check the copy
    152152        // - sizes of matched object
    153         assert(Dest.GetObjectSize(0) == Source.GetObjectSize(0));
    154         assert(Dest.GetObjectSize(1) == Source.GetObjectSize(1));
     153        assert(Dest.getObjectSize(0) == Source.getObjectSize(0));
     154        assert(Dest.getObjectSize(1) == Source.getObjectSize(1));
    155155        // - the copy should be full, too
    156         assert(Dest.IsFull() == true);
     156        assert(Dest.isFull() == true);
    157157        // - the copy should have exactly the same assignments in matching
    158158        for (iObj = 0; iObj < iSize; iObj++)
     
    160160            // all object should be matched!
    161161            // check both directions: 0 -> 1
    162             assert(Dest.IsMatched(0, iObj) == true);
    163             assert(iObj == Dest.GetMatchedIndex(0, iObj));
     162            assert(Dest.isMatched(0, iObj) == true);
     163            assert(iObj == Dest.getMatchedIndex(0, iObj));
    164164            // and: 1 -> 0
    165             assert(Dest.IsMatched(1, iObj) == true);
    166             assert(iObj == Dest.GetMatchedIndex(1, iObj));
     165            assert(Dest.isMatched(1, iObj) == true);
     166            assert(iObj == Dest.getMatchedIndex(1, iObj));
    167167        }
    168168        // make it empty
    169         Dest.Empty();
     169        Dest.empty();
    170170        // and check once more
    171         assert(Dest.IsEmpty() == true);
     171        assert(Dest.isEmpty() == true);
    172172    }
    173173
     
    176176        SimilMatching Source(iSize, iSize);
    177177        // check if it is empty
    178         assert(Source.IsEmpty() == true);
     178        assert(Source.isEmpty() == true);
    179179        // check sizes of objects
    180         assert(Source.GetObjectSize(0) == iSize);
    181         assert(Source.GetObjectSize(1) == iSize);
     180        assert(Source.getObjectSize(0) == iSize);
     181        assert(Source.getObjectSize(1) == iSize);
    182182        // match objects (iObj, N - iObj - 1)
    183183        for (iObj = 0; iObj < iSize; iObj++)
    184184        {
    185             Source.Match(0, iObj, 1, iSize - iObj - 1);
     185            Source.match(0, iObj, 1, iSize - iObj - 1);
    186186        }
    187187        // check if the matching is full
    188         assert(Source.IsFull() == true);
     188        assert(Source.isFull() == true);
    189189        // now create a copy of the matching
    190190        SimilMatching Dest(Source);
    191191        // check the copy
    192192        // - sizes of matched object
    193         assert(Dest.GetObjectSize(0) == Source.GetObjectSize(0));
    194         assert(Dest.GetObjectSize(1) == Source.GetObjectSize(1));
     193        assert(Dest.getObjectSize(0) == Source.getObjectSize(0));
     194        assert(Dest.getObjectSize(1) == Source.getObjectSize(1));
    195195        // - the copy should be full, too
    196         assert(Dest.IsFull() == true);
     196        assert(Dest.isFull() == true);
    197197        // - the copy should have exactly the same assignments in matching
    198198        for (iObj = 0; iObj < iSize; iObj++)
     
    200200            // all object should be matched!
    201201            // check both directions: 0 -> 1
    202             assert(Dest.IsMatched(0, iObj) == true);
    203             assert((iSize - iObj - 1) == Dest.GetMatchedIndex(0, iObj));
     202            assert(Dest.isMatched(0, iObj) == true);
     203            assert((iSize - iObj - 1) == Dest.getMatchedIndex(0, iObj));
    204204            // and: 1 -> 0
    205             assert(Dest.IsMatched(1, iObj) == true);
    206             assert((iSize - iObj - 1) == Dest.GetMatchedIndex(1, iObj));
     205            assert(Dest.isMatched(1, iObj) == true);
     206            assert((iSize - iObj - 1) == Dest.getMatchedIndex(1, iObj));
    207207        }
    208208        // make it empty
    209         Dest.Empty();
     209        Dest.empty();
    210210        // and check once more
    211         assert(Dest.IsEmpty() == true);
     211        assert(Dest.isEmpty() == true);
    212212    }
    213213
     
    216216        SimilMatching Source(iSize, 2 * iSize);
    217217        // check if it is empty
    218         assert(Source.IsEmpty() == true);
     218        assert(Source.isEmpty() == true);
    219219        // check sizes of objects
    220         assert(Source.GetObjectSize(0) == iSize);
    221         assert(Source.GetObjectSize(1) == 2 * iSize);
     220        assert(Source.getObjectSize(0) == iSize);
     221        assert(Source.getObjectSize(1) == 2 * iSize);
    222222        // match objects (iObj, 2 * iObj)
    223223        for (iObj = 0; iObj < iSize; iObj++)
    224224        {
    225             Source.Match(0, iObj, 1, 2 * iObj);
     225            Source.match(0, iObj, 1, 2 * iObj);
    226226        }
    227227        // check if the matching is full (should be, as the smaller set is completely matched
    228         assert(Source.IsFull() == true);
     228        assert(Source.isFull() == true);
    229229        // now create a copy of the matching
    230230        SimilMatching Dest(Source);
    231231        // check the copy
    232232        // - sizes of matched object
    233         assert(Dest.GetObjectSize(0) == Source.GetObjectSize(0));
    234         assert(Dest.GetObjectSize(1) == Source.GetObjectSize(1));
     233        assert(Dest.getObjectSize(0) == Source.getObjectSize(0));
     234        assert(Dest.getObjectSize(1) == Source.getObjectSize(1));
    235235        // - the copy should be full, too
    236         assert(Dest.IsFull() == true);
     236        assert(Dest.isFull() == true);
    237237        // - the copy should have exactly the same assignments in matching
    238238        for (iObj = 0; iObj < iSize; iObj++)
     
    240240            // check both directions: 0 -> 1
    241241            // (all matched, (iObj, 2 * iObj))
    242             assert(Dest.IsMatched(0, iObj) == true);
    243             assert((2 * iObj) == Dest.GetMatchedIndex(0, iObj));
     242            assert(Dest.isMatched(0, iObj) == true);
     243            assert((2 * iObj) == Dest.getMatchedIndex(0, iObj));
    244244            // and direction; 1 -> 0
    245245            // (only even are matched, ( 2 * iObj, iObj))
    246246            // for 2 * iObj (which are even): matched
    247             assert(Dest.IsMatched(1, 2 * iObj) == true);
    248             assert(iObj == Dest.GetMatchedIndex(1, 2 * iObj));
     247            assert(Dest.isMatched(1, 2 * iObj) == true);
     248            assert(iObj == Dest.getMatchedIndex(1, 2 * iObj));
    249249            // for 2 * iObj + 1 (which are odd): unmatched
    250             assert(Dest.IsMatched(1, 2 * iObj + 1) == false);
     250            assert(Dest.isMatched(1, 2 * iObj + 1) == false);
    251251        }
    252252        // make it empty
    253         Dest.Empty();
     253        Dest.empty();
    254254        // and check once more
    255         assert(Dest.IsEmpty() == true);
     255        assert(Dest.isEmpty() == true);
    256256    }
    257257
     
    273273
    274274    // matching is empty
    275     assert(match1.IsEmpty() == true);
     275    assert(match1.isEmpty() == true);
    276276
    277277    // create matching - (i,i)
     
    280280
    281281        // matching is not full
    282         assert(match1.IsFull() == false);
     282        assert(match1.isFull() == false);
    283283
    284284        // these are not matched yet
    285         assert(match1.IsMatched(0, i) == false);
    286         assert(match1.IsMatched(1, i) == false);
     285        assert(match1.isMatched(0, i) == false);
     286        assert(match1.isMatched(1, i) == false);
    287287
    288288        // now - match!
    289         match1.Match(0, i, 1, i);
     289        match1.match(0, i, 1, i);
    290290
    291291        // matching is not empty
    292         assert(match1.IsEmpty() == false);
     292        assert(match1.isEmpty() == false);
    293293
    294294        // now they are matched
    295         assert(match1.IsMatched(0, i) == true);
    296         assert(match1.IsMatched(1, i) == true);
     295        assert(match1.isMatched(0, i) == true);
     296        assert(match1.isMatched(1, i) == true);
    297297
    298298        // check the matched index for object 0 and 1
    299         assert(match1.GetMatchedIndex(0, i) == i);
    300         assert(match1.GetMatchedIndex(1, i) == i);
     299        assert(match1.getMatchedIndex(0, i) == i);
     300        assert(match1.getMatchedIndex(1, i) == i);
    301301    }
    302302
    303303    // now matching have to be full
    304     assert(match1.IsFull() == true);
     304    assert(match1.isFull() == true);
    305305
    306306    // check some symmetric matching
     
    308308
    309309    // matching is empty
    310     assert(match2.IsEmpty() == true);
     310    assert(match2.isEmpty() == true);
    311311
    312312    // create matching - (i, nSize1 - 1 - i)
     
    315315
    316316        // matching is not full
    317         assert(match2.IsFull() == false);
     317        assert(match2.isFull() == false);
    318318
    319319        // these are not matched yet
    320         assert(match2.IsMatched(0, i) == false);
    321         assert(match2.IsMatched(1, nSize1 - 1 - i) == false);
     320        assert(match2.isMatched(0, i) == false);
     321        assert(match2.isMatched(1, nSize1 - 1 - i) == false);
    322322
    323323        // now - match (but use the opposite syntax)!
    324         match2.Match(1, nSize1 - 1 - i, 0, i);
     324        match2.match(1, nSize1 - 1 - i, 0, i);
    325325
    326326        // matching is not empty
    327         assert(match2.IsEmpty() == false);
     327        assert(match2.isEmpty() == false);
    328328
    329329        // now they are matched
    330         assert(match2.IsMatched(0, i) == true);
    331         assert(match2.IsMatched(1, nSize1 - 1 - i) == true);
     330        assert(match2.isMatched(0, i) == true);
     331        assert(match2.isMatched(1, nSize1 - 1 - i) == true);
    332332
    333333        // check the matched index for object 0 and 1
    334         assert(match2.GetMatchedIndex(0, i) == (nSize1 - 1 - i));
    335         assert(match2.GetMatchedIndex(1, nSize1 - 1 - i) == i);
     334        assert(match2.getMatchedIndex(0, i) == (nSize1 - 1 - i));
     335        assert(match2.getMatchedIndex(1, nSize1 - 1 - i) == i);
    336336    }
    337337
    338338    // now matching have to be full
    339     assert(match2.IsFull() == true);
     339    assert(match2.isFull() == true);
    340340
    341341    // check some asymmnetic matching, too
     
    343343
    344344    // matching is empty
    345     assert(match3.IsEmpty() == true);
     345    assert(match3.isEmpty() == true);
    346346
    347347    // create matching - (i, 2 * i)
     
    350350
    351351        // matching is not full
    352         assert(match3.IsFull() == false);
     352        assert(match3.isFull() == false);
    353353
    354354        // these are not matched yet
    355         assert(match3.IsMatched(0, i) == false);
    356         assert(match3.IsMatched(1, 2 * i) == false);
     355        assert(match3.isMatched(0, i) == false);
     356        assert(match3.isMatched(1, 2 * i) == false);
    357357
    358358        // now - match (but use the opposite syntax)!
    359         match3.Match(1, 2 * i, 0, i);
     359        match3.match(1, 2 * i, 0, i);
    360360
    361361        // matching is not empty
    362         assert(match3.IsEmpty() == false);
     362        assert(match3.isEmpty() == false);
    363363
    364364        // now they are matched
    365         assert(match3.IsMatched(0, i) == true);
    366         assert(match3.IsMatched(1, 2 * i) == true);
     365        assert(match3.isMatched(0, i) == true);
     366        assert(match3.isMatched(1, 2 * i) == true);
    367367
    368368        // but the odd elements of object 1 are not matched
    369         assert(match3.IsMatched(1, 2 * i + 1) == false);
     369        assert(match3.isMatched(1, 2 * i + 1) == false);
    370370
    371371        // check the matched index for object 0 and 1
    372         assert(match3.GetMatchedIndex(0, i) == 2 * i);
    373         assert(match3.GetMatchedIndex(1, 2 * i) == i);
     372        assert(match3.getMatchedIndex(0, i) == 2 * i);
     373        assert(match3.getMatchedIndex(1, 2 * i) == i);
    374374    }
    375375
    376376    // now matching have to be full (because the smallest object has all elements matched).
    377     assert(match3.IsFull() == true);
     377    assert(match3.isFull() == true);
    378378
    379379    return 0;
Note: See TracChangeset for help on using the changeset viewer.