Changeset 1044


Ignore:
Timestamp:
12/10/20 22:33:22 (5 weeks ago)
Author:
oriona
Message:

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

Location:
cpp
Files:
14 added
5 edited
2 moved

Legend:

Unmodified
Added
Removed
  • cpp/frams/Makefile-SDK-files

    r1035 r1044  
    22
    33# ALL_DIRS is later expanded by the shell, no spaces/newlines allowed, or it breaks
    4 ALL_DIRS={common,PrintFloat,frams,frams/canvas,frams/config,common/loggers,frams/genetics,frams/genetics/f0,frams/genetics/f1,frams/genetics/f2,frams/genetics/f3,frams/genetics/f4,frams/genetics/f5,frams/genetics/f6,frams/genetics/f7,frams/genetics/f8,frams/genetics/f9,frams/genetics/fn,frams/genetics/fF,frams/genetics/fT,frams/genetics/fB,frams/genetics/fH,frams/genetics/fL,frams/genetics/fS,frams/model,frams/neuro,frams/neuro/impl,frams/param,frams/test,frams/util,frams/vm/classes,common/virtfile,frams/_demos,frams/model/geometry,frams/_demos/geometry,frams/model/similarity,frams/model/similarity/hungarian,frams/model/similarity/SVD}
     4ALL_DIRS={common,PrintFloat,frams,frams/canvas,frams/config,common/loggers,frams/genetics,frams/genetics/f0,frams/genetics/f1,frams/genetics/f2,frams/genetics/f3,frams/genetics/f4,frams/genetics/f5,frams/genetics/f6,frams/genetics/f7,frams/genetics/f8,frams/genetics/f9,frams/genetics/fn,frams/genetics/fF,frams/genetics/fT,frams/genetics/fB,frams/genetics/fH,frams/genetics/fL,frams/genetics/fS,frams/model,frams/neuro,frams/neuro/impl,frams/param,frams/test,frams/util,frams/vm/classes,common/virtfile,frams/_demos,frams/model/geometry,frams/_demos/geometry,frams/model/similarity,frams/model/similarity/hungarian,frams/model/similarity/SVD,frams/model/similarity/EMD}
    55
    66GEOMETRY_OBJS=frams/model/geometry/meshbuilder.o frams/model/geometry/modelgeometryinfo.o frams/model/geometry/geometryutils.o
     
    3737NEURO_OBJS=frams/neuro/neuroimpl.o frams/neuro/neurofactory.o frams/neuro/impl/neuroimpl-simple.o frams/neuro/impl/neuroimpl-channels.o frams/neuro/impl/neuroimpl-fuzzy.o frams/neuro/impl/neuroimpl-fuzzy-f0.o
    3838
    39 SIMILARITY_OBJS=frams/model/similarity/hungarian/hungarian.o frams/model/similarity/SVD/lapack.o frams/model/similarity/SVD/matrix_tools.o frams/model/similarity/simil_match.o frams/model/similarity/simil_model.o
     39SIMILARITY_OBJS=frams/_demos/geometry/geometrytestutils.o frams/model/similarity/measure-greedy.o frams/model/similarity/measure-hungarian.o frams/model/similarity/measure-distribution.o frams/model/similarity/measure-mds-based.o frams/model/similarity/simil-measure.o frams/model/similarity/hungarian/hungarian.o frams/model/similarity/SVD/lapack.o frams/model/similarity/SVD/matrix_tools.o frams/model/similarity/simil-match.o
    4040
    4141NN_LAYOUT_OBJS=frams/canvas/nn_layout_model.o frams/canvas/nn_simple_layout.o frams/canvas/nn_smart_layout.o
     
    9696SIMIL_TEST_OBJS=frams/_demos/simil_test.o $(SIMILARITY_OBJS) frams/_demos/genotypeloader.o frams/_demos/genotypemini.o frams/param/multiparamload.o common/virtfile/stdiofile.o $(STDOUT_LOGGER_OBJS) $(SDK_OBJS) $(GENOCONV_AND_GENMAN_SDK_OBJS)
    9797
    98 SIMIL_UNITTESTS_OBJS=frams/_demos/simil_unittests.o frams/model/similarity/simil_match.o
     98SIMIL_UNITTESTS_OBJS=frams/_demos/simil_unittests.o frams/model/similarity/simil-match.o
    9999
    100100PARAMTREE_STDIN_TEST_OBJS=frams/_demos/paramtree_stdin_test.o frams/_demos/paramtree_print.o $(STDOUT_LOGGER_OBJS) common/virtfile/stdiofile.o $(SDK_OBJS) frams/param/paramtree.o
    101101
    102 PARAMTREE_PARAMLIST_TEST_OBJS=$(sort frams/_demos/paramtree_paramlist_test.o frams/_demos/paramtree_print.o $(STDOUT_LOGGER_OBJS) common/virtfile/stdiofile.o $(SDK_OBJS) $(GENOCONV_AND_GENMAN_SDK_OBJS) frams/neuro/neuroimpl.o frams/neuro/neurofactory.o frams/neuro/impl/neuroimpl-simple.o frams/neuro/impl/neuroimpl-channels.o frams/neuro/impl/neuroimpl-fuzzy.o frams/neuro/impl/neuroimpl-fuzzy-f0.o $(GENOTYPE_LOADER_OBJS) $(GEOMETRY_OBJS) frams/model/geometry/modelgeoclass.o frams/model/modelobj.o frams/param/paramtree.o)
     102PARAMTREE_PARAMLIST_TEST_OBJS=$(sort frams/_demos/paramtree_paramlist_test.o frams/_demos/paramtree_print.o $(STDOUT_LOGGER_OBJS) common/virtfile/stdiofile.o $(SDK_OBJS) $(GENOCONV_AND_GENMAN_SDK_OBJS) frams/neuro/neuroimpl.o frams/neuro/neurofactory.o frams/neuro/impl/neuroimpl-simple.o frams/neuro/impl/neuroimpl-channels.o frams/neuro/impl/neuroimpl-fuzzy.o frams/neuro/impl/neuroimpl-fuzzy-f0.o $(GENOTYPE_LOADER_OBJS) $(GEOMETRY_OBJS) $(SIMILARITY_OBJS) frams/model/geometry/modelgeoclass.o frams/model/modelobj.o frams/param/paramtree.o)
    103103
    104104MUTABLEPARAM_TEST_OBJS=frams/_demos/mutableparam_test.o $(STDOUT_LOGGER_OBJS) common/virtfile/stdiofile.o $(SDK_OBJS) frams/param/mutableparam.o frams/param/mutparamlist.o frams/param/paramtrans.o
  • cpp/frams/_demos/paramtree_paramlist_test.cpp

    r795 r1044  
    1111#include <frams/model/geometry/modelgeoclass.h>
    1212#include <frams/model/modelobj.h>
     13#include <frams/model/similarity/measure-distribution.h>
     14#include <frams/model/similarity/measure-greedy.h>
     15#include <frams/model/similarity/measure-hungarian.h>
    1316#include "genotypeloader.h"
    1417#include "paramtree_print.h"
     
    2730        NeuroNetConfig nn_config(&neurofac);
    2831        ModelGeometry modelgeo;
     32        SimilMeasureDistribution simil_measure_distr;
     33        SimilMeasureGreedy simil_measure_greedy;
     34        SimilMeasureHungarian simil_measure_hungarian;
    2935
    3036        MutableParamList combined;
     
    3945        combined += &nn_config.par;
    4046        combined += &modelgeo.par;
     47        combined += &simil_measure_distr.localpar;
     48        combined += &simil_measure_greedy.localpar;
     49        combined += &simil_measure_hungarian.localpar;
    4150
    4251        ParamTree tree(&combined);
  • cpp/frams/_demos/simil_test.cpp

    r1005 r1044  
    55
    66#include <vector>
     7#include <string>
    78#include "common/loggers/loggertostdout.h"
    89#include "frams/_demos/genotypeloader.h"
    910#include "frams/genetics/preconfigured.h"
    1011#include "common/virtfile/stdiofile.h"
    11 #include "frams/model/similarity/simil_model.h"
    12 
    13 
     12#include "frams/model/similarity/measure-distribution.h"
     13#include "frams/model/similarity/measure-greedy.h"
     14#include "frams/model/similarity/measure-hungarian.h"
     15
     16using namespace std;
     17
     18int add_double_param(std::vector<string> *args, int pos, std::vector<double> *params, std::vector<string> *params_names)
     19{
     20    for (unsigned int i = 0; i < params_names->size(); i++)
     21    {
     22        try
     23        {
     24            params->push_back(std::stod(args->at(pos)));
     25            pos++;
     26        }
     27        catch (const std::invalid_argument&)
     28        {
     29            printf("%s should be a number\n", params_names->at(i).c_str());
     30            return -1;
     31        }
     32        catch (const std::out_of_range&)
     33        {
     34            printf("%s should be inside double range\n", params_names->at(i).c_str());
     35            return -1;
     36        }
     37    }
     38    return 0;
     39}
    1440
    1541/** Computes a matrix of distances between all genotypes in the specified
     
    1844int main(int argc, char *argv[])
    1945{
    20         LoggerToStdout messages_to_stdout(LoggerBase::Enable);
    21         int iCurrParam = 0; // index of the currently processed parameter
    22         char *szCurrParam = NULL;
    23         ModelSimil M; // similarity computing object
    24         bool bPrintNames = false; // specifies if names of genotypes are to be printed
    25         int nResult = 0; // a temporary result
    26 
    27         if (argc < 8)
    28         {
    29                 printf("Too few parameters!\n");
    30                 printf("Command line: [-names] <genotypesFile> <measure> <w_dP> <w_dDEG> <w_dNEU> <w_dGEO> <fixZaxis?>\n\n");
    31 
    32                 printf("Parameters:\n");
    33                 printf("  <genotypesFile> name of a file with genotypes\n");
    34                 printf("  <measure> similarity measure\n");
    35                 printf("  <w_dP> weight of the difference in the number of parts\n");
    36                 printf("  <w_dDEG> weight of the difference in degrees of matched parts\n");
    37                 printf("  <w_dNEU> weight of the difference in neurons of matched parts\n");
    38                 printf("  <w_dGEO> weight of the distance of matched parts\n");
    39                 printf("  <fixZaxis?> should the 'z' (vertical) coordinate be fixed during the alignment? (0 or 1)\n\n");
    40 
    41                 printf("Switches:\n");
    42                 printf("  -names specifies that the number and names of genotypes are to be printed to output\n");
    43                 printf("  before the distance matrix; by default the number and names are not printed\n\n");
    44 
    45                 printf("Outputs a symmetric distance matrix in the format:\n");
    46                 printf("  <row_1> (columns in a row are separated by TABs)\n");
    47                 printf("  ...\n");
    48                 printf("  <row_n>\n");
    49 
    50                 return -1;
    51         }
    52 
    53         // prepare output parameters from .gen file
    54         vector<Geno *> pvGenos;
    55         vector<char *> pvNames;
    56 
    57         // check if there is a switch
    58         iCurrParam = 1;
    59         szCurrParam = argv[iCurrParam];
    60         if (strcmp(szCurrParam, "-names") == 0)
    61         {
    62                 // switch "-names" was given; print names also
    63                 bPrintNames = true;
    64                 // pass to the next parameter
    65                 iCurrParam++;
    66         }
    67 
    68         // check the parameters
    69         // get <genotypesFile> name from command line
    70         char *szFileName = argv[iCurrParam];
    71 
    72         // initially set measure components' weights to invalid values (negative)
    73         for (int i = 0; i < M.GetNOFactors(); i++)
    74         {
    75                 M.m_adFactors[i] = -1.0;
    76         }
    77 
    78         iCurrParam++;
    79         szCurrParam = argv[iCurrParam];
    80         int measure_type = -1;
    81         nResult = sscanf(szCurrParam, "%d", &measure_type);
    82         if (nResult != 1)
    83         {
    84                 printf("Measure type should be a number!\n");
    85                 return -1;
    86         }
    87 
    88         if (measure_type != 0 && measure_type != 1)
    89         {
    90                 printf("Measure type should be 0 (flexible criteria order and optimal matching) or 1 (vertex degree order and greedy matching)!\n");
    91                 return -1;
    92         }
    93 
    94         M.matching_method = measure_type;
    95 
    96         const char *params[] = { "<w_dP>", "<w_dDEG>", "<w_dNEU>", "<w_dGEO>" };
    97         for (int i = 0; i < M.GetNOFactors(); i++)
    98         {
    99                 iCurrParam++;
    100                 szCurrParam = argv[iCurrParam];
    101                 nResult = sscanf(szCurrParam, "%lf", &M.m_adFactors[i]);
    102                 if (nResult != 1)
    103                 {
    104                         // <w_dX> is not a number -- error
    105                         printf("%s", params[i]);
    106                         printf(" should be a number\n");
    107                         return -1;
    108                 }
    109                 else
    110                 {
    111                         // <w_dX> is a number; check if nonnegative
    112                         if (M.m_adFactors[i] < 0.0)
    113                         {
    114                                 printf("%s", params[i]);
    115                                 printf(" should be a nonnegative number\n");
    116                                 return -1;
    117                         }
    118                 }
    119         }
    120 
    121         iCurrParam++;
    122         szCurrParam = argv[iCurrParam];
    123         nResult = sscanf(szCurrParam, "%d", &M.fixedZaxis);
    124         if (nResult != 1)
    125         {
    126                 // <isZFixed> is not a number -- error
    127                 printf("<isZFixed> should be a number\n");
    128                 return -1;
    129         }
    130         else if (M.fixedZaxis != 0 && M.fixedZaxis != 1)
    131         {
    132                 printf("<isZFixed>=%d. <isZFixed> should be equal to 0 or 1\n", M.fixedZaxis);
    133                 return -1;
    134         }
    135 
    136         // read the input file
    137         // prepare loading of genotypes from a .gen file
    138         // create some basic genotype converters
    139         PreconfiguredGenetics genetics;
    140         StdioFileSystem_autoselect stdiofilesys;
    141 
    142         long count = 0, totalsize = 0;
    143         GenotypeMiniLoader loader(szFileName);
    144         GenotypeMini *loaded;
    145         while (loaded = loader.loadNextGenotype())
    146         {
    147                 // while a valid genotype was loaded
    148                 count++;
    149                 totalsize += loaded->genotype.length();
    150                 // create a Geno object based on the MiniGenotype
    151                 Geno *pNextGenotype = new Geno(loaded->genotype);
    152                 if ((pNextGenotype != NULL) && (pNextGenotype->isValid()))
    153                 {
    154                         pvGenos.push_back(pNextGenotype);
    155                         char *szNewName = new char[loaded->name.length() + 1];
    156                         strcpy(szNewName, loaded->name.c_str());
    157                         pvNames.push_back(szNewName);
    158                 }
    159                 else
    160                 {
    161                         printf("Genotype %2li is not valid\n", count);
    162                         if (pNextGenotype != NULL) delete pNextGenotype;
    163                 }
    164         }
    165         if (loader.getStatus() == GenotypeMiniLoader::OnError)
    166         {
    167                 printf("Error: %s", loader.getError().c_str());
    168         }
    169 
    170         double dSimilarity = 0.0;
    171         double **aaSimil = NULL; // array of similarities
    172 
    173         // create an empty array of similarities
    174         aaSimil = new double*[pvGenos.size()];
    175         for (unsigned int k = 0; k < pvGenos.size(); k++)
    176         {
    177                 aaSimil[k] = new double[pvGenos.size()];
    178                 for (unsigned int l = 0; l < pvGenos.size(); l++)
    179                         aaSimil[k][l] = 0.0;
    180         }
    181 
    182         // compute and store similarities
    183         for (unsigned int i = 0; i < pvGenos.size(); i++)
    184         {
    185                 for (unsigned int j = 0; j < pvGenos.size(); j++)
    186                 {
    187                         dSimilarity = M.EvaluateDistance(pvGenos.operator[](i), pvGenos.operator[](j));
    188                         aaSimil[i][j] = dSimilarity;
    189                 }
    190         }
    191 
    192         if (bPrintNames)
    193         {
    194                 // if the "-names" switch was given, print the number of genotypes and their names
    195                 printf("%li\n", pvGenos.size());
    196                 for (unsigned int iGen = 0; iGen < pvNames.size(); iGen++)
    197                 {
    198                         printf("%s\n", pvNames.at(iGen));
    199                 }
    200         }
    201 
    202         // print out the matrix of similarities
    203         for (unsigned int i = 0; i < pvGenos.size(); i++)
    204         {
    205                 for (unsigned int j = 0; j < pvGenos.size(); j++)
    206                 {
    207                         printf("%.2lf\t", aaSimil[i][j]);
    208                 }
    209                 printf("\n");
    210         }
    211 
    212         // delete vectors and arrays
    213         for (unsigned int i = 0; i < pvGenos.size(); i++)
    214         {
    215                 delete pvGenos.operator[](i);
    216                 delete[] pvNames.operator[](i);
    217                 delete[] aaSimil[i];
    218         }
    219 
    220         delete[] aaSimil;
    221 
    222         return 0;
     46    typedef double *pDouble;
     47    LoggerToStdout messages_to_stdout(LoggerBase::Enable);
     48    SimilMeasure *simil_measure = nullptr;
     49    if (argc < 5)
     50    {
     51        printf("Too few parameters!\n");
     52        printf("Command line: [-names] <genotypesFile> <measure (greedy/hungarian)> <w_dP> <w_dDEG> <w_dNEU> <w_dGEO> <fixZaxis?>\n\n");
     53        printf("Command line: [-names] <genotypesFile> <measure (distribution)> <desc> <simil> <dens> <bins> <samp_num>\n\n");
     54        printf("Parameters:\n");
     55        printf("  <genotypesFile> name of a file with genotypes\n");
     56        printf("  <measure> similarity measure name (greedy/hungarian/distribution)\n");
     57        printf("\n");
     58        printf("Parameters of greedy and hungarian measures:\n");
     59        printf("  <w_dP> weight of the difference in the number of parts\n");
     60        printf("  <w_dDEG> weight of the difference in degrees of matched parts\n");
     61        printf("  <w_dNEU> weight of the difference in neurons of matched parts\n");
     62        printf("  <w_dGEO> weight of the distance of matched parts\n");
     63        printf("  <fixZaxis?> should the 'z' (vertical) coordinate be fixed during the alignment? (0 or 1)\n\n");
     64        printf("Parameters of distribution measure:\n");
     65        printf("  <dens> sampling density\n");
     66        printf("  <bins> number of histogram bins\n");
     67        printf("  <samp_num> number of samples taken\n\n");
     68
     69        printf("Switches:\n");
     70        printf("  -names specifies that the number and names of genotypes are to be printed to output\n");
     71        printf("  before the distance matrix; by default the number and names are not printed\n\n");
     72
     73        printf("Outputs a symmetric distance matrix in the format:\n");
     74        printf("  <row_1> (columns in a row are separated by TABs)\n");
     75        printf("  ...\n");
     76        printf("  <row_n>\n");
     77
     78        return -1;
     79    }
     80
     81    std::vector<string> args;
     82    for (int i = 1; i < argc; i++)
     83        args.push_back(std::string(argv[i]));
     84
     85    bool print_names = false;
     86
     87    int pos = 1;
     88    if (args.at(0).compare("-names")==0)
     89    {
     90        print_names = true;
     91        pos = 2;
     92    }
     93
     94    string measure_name = args.at(pos);
     95    pos++;
     96    std::vector<double> params;
     97
     98    if (measure_name.compare("greedy")==0 || measure_name.compare("hungarian")==0)
     99    {
     100        std::vector<string> params_names{ "<w_dP>", "<w_dDEG>", "<w_dNEU>", "<w_dGEO>",  "<fixZaxis?>" };
     101
     102        if (add_double_param(&args, pos, &params, &params_names) == -1)
     103            return -1;
     104
     105        if (measure_name.compare("greedy")==0)
     106            simil_measure = new SimilMeasureGreedy();
     107        else
     108            simil_measure = new SimilMeasureHungarian();
     109    }
     110
     111
     112    else if (measure_name.compare("distribution")==0)
     113    {
     114        std::vector<string> params_names{ "<dens>", "<bins>", "<samp_num>" };
     115
     116        if (add_double_param(&args, pos, &params, &params_names)==-1)
     117            return -1;
     118
     119        simil_measure = new SimilMeasureDistribution();
     120    }
     121
     122    else
     123    {
     124        printf("Measure type should be greedy (flexible criteria order and optimal matching), hungarian (vertex degree order and greedy matching) or distribution!\n");
     125        return -1;
     126    }
     127
     128    simil_measure->setParams(params);
     129
     130    // read the input file
     131    // prepare loading of genotypes from a .gen file
     132    // create some basic genotype converters
     133    PreconfiguredGenetics genetics;
     134    StdioFileSystem_autoselect stdiofilesys;
     135
     136    // prepare output parameters from .gen file
     137    vector<Geno *> pvGenos;
     138    vector<char *> pvNames;
     139
     140    long count = 0, totalsize = 0;
     141    GenotypeMiniLoader loader(args.at(0).c_str());
     142    GenotypeMini *loaded;
     143    while (loaded = loader.loadNextGenotype())
     144    {
     145        // while a valid genotype was loaded
     146        count++;
     147        totalsize += loaded->genotype.length();
     148        // create a Geno object based on the MiniGenotype
     149        Geno *pNextGenotype = new Geno(loaded->genotype);
     150        if ((pNextGenotype != NULL) && (pNextGenotype->isValid()))
     151        {
     152            pvGenos.push_back(pNextGenotype);
     153            char *szNewName = new char[loaded->name.length() + 1];
     154            strcpy(szNewName, loaded->name.c_str());
     155            pvNames.push_back(szNewName);
     156        }
     157        else
     158        {
     159            printf("Genotype %2li is not valid\n", count);
     160            if (pNextGenotype != NULL) delete pNextGenotype;
     161        }
     162    }
     163    if (loader.getStatus() == GenotypeMiniLoader::OnError)
     164    {
     165        printf("Error: %s", loader.getError().c_str());
     166    }
     167
     168    double dSimilarity = 0.0;
     169    double **aaSimil = NULL; // array of similarities
     170
     171    // create the empty array of similarities
     172    aaSimil = new pDouble[pvGenos.size()];
     173    for (unsigned int k = 0; k < pvGenos.size(); k++)
     174    {
     175        aaSimil[k] = new double[pvGenos.size()];
     176        for (unsigned int l = 0; l < pvGenos.size(); l++)
     177            aaSimil[k][l] = 0.0;
     178    }
     179
     180
     181
     182    // compute and remember similarities
     183    for (unsigned int i = 0; i < pvGenos.size(); i++)
     184    {
     185        for (unsigned int j = 0; j < pvGenos.size(); j++)
     186        {
     187            dSimilarity = simil_measure->evaluateDistance(pvGenos.operator[](i), pvGenos.operator[](j));
     188            aaSimil[i][j] = dSimilarity;
     189        }
     190    }
     191
     192    if (print_names)
     193    {
     194        // if "-names" switch was given, print the number of genotypes and their names
     195        printf("%li\n", pvGenos.size());
     196        for (unsigned int iGen = 0; iGen < pvNames.size(); iGen++)
     197        {
     198            printf("%s\n", pvNames.at(iGen));
     199        }
     200    }
     201
     202    // print out the matrix of similarities
     203    for (unsigned int i = 0; i < pvGenos.size(); i++)
     204    {
     205        for (unsigned int j = 0; j < pvGenos.size(); j++)
     206        {
     207            printf("%.2lf\t", aaSimil[i][j]);
     208        }
     209        printf("\n");
     210    }
     211
     212    // delete vectors and arrays
     213    for (unsigned int i = 0; i < pvGenos.size(); i++)
     214    {
     215        delete pvGenos.operator[](i);
     216        delete[] pvNames.operator[](i);
     217        delete[] aaSimil[i];
     218    }
     219
     220    delete[] aaSimil;
     221    delete simil_measure;
     222
     223    return 0;
    223224}
  • 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;
  • cpp/frams/model/similarity/simil-match.cpp

    r1043 r1044  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2019  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2020  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
    55#include <assert.h>
    66#include <stdio.h>
    7 #include "simil_match.h"
     7#include "simil-match.h"
    88
    99/** Creates an empty matching for two objects of specified size.
     
    6363                @return Size of the object (in elements).
    6464 */
    65 int SimilMatching::GetObjectSize(int Obj)
     65int SimilMatching::getObjectSize(int Obj)
    6666{
    6767        // check parameter
     
    8181
    8282 */
    83 void SimilMatching::Match(int Obj0, int Index0, int Obj1, int Index1)
     83void SimilMatching::match(int Obj0, int Index0, int Obj1, int Index1)
    8484{
    8585        // check parameters of object 0
     
    103103                @return true if the given element is matched, false otherwise.
    104104 */
    105 bool SimilMatching::IsMatched(int Obj, int Index)
     105bool SimilMatching::isMatched(int Obj, int Index)
    106106{
    107107        // check parameters
     
    128128                (check IsMatched() before using GetMatchedIndex()).
    129129 */
    130 int SimilMatching::GetMatchedIndex(int Obj, int Index)
     130int SimilMatching::getMatchedIndex(int Obj, int Index)
    131131{
    132132        // check parameters
     
    142142                @return true if matching is full, false otherwise.
    143143 */
    144 bool SimilMatching::IsFull()
     144bool SimilMatching::isFull()
    145145{
    146146        // assume that the matching is full
     
    177177        @return true if matching is empty, otherwise - false.
    178178 */
    179 bool SimilMatching::IsEmpty()
     179bool SimilMatching::isEmpty()
    180180{
    181181        // result - assume that matching is empty
     
    201201/** Makes the matching completely empty. After a call to this method IsEmpty() should return true.
    202202 */
    203 void SimilMatching::Empty()
     203void SimilMatching::empty()
    204204{
    205205        for (int iObj = 0; iObj < 2; iObj++) // a counter of objects
     
    215215
    216216        // the exit condition
    217         assert(IsEmpty() == true);
     217        assert(isEmpty() == true);
    218218}
    219219
    220220/** Prints the current state of the matching
    221221 */
    222 void SimilMatching::PrintMatching()
     222void SimilMatching::printMatching()
    223223{
    224224        int nBigger;
     
    249249                for (unsigned int i = 0; i < m_apvMatched[nObj]->size(); i++)
    250250                {
    251                         if (IsMatched(nObj, i))
     251                        if (isMatched(nObj, i))
    252252                        {
    253253                                // if the element is matched - print the index
    254                                 printf("%2d ", GetMatchedIndex(nObj, i));
     254                                printf("%2d ", getMatchedIndex(nObj, i));
    255255                        }
    256256                        else
  • cpp/frams/model/similarity/simil-match.h

    r1043 r1044  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2019  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2020  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
     
    2626        SimilMatching(const SimilMatching &Source);
    2727        ~SimilMatching();
    28         int GetObjectSize(int Obj);
    29         void Match(int Obj0, int Index0, int Obj1, int Index1);
    30         bool IsMatched(int Obj, int Index);
    31         int GetMatchedIndex(int Obj, int index);
    32         bool IsFull();
    33         bool IsEmpty();
    34         void Empty();
    35         void PrintMatching();
     28        int getObjectSize(int Obj);
     29        void match(int Obj0, int Index0, int Obj1, int Index1);
     30        bool isMatched(int Obj, int Index);
     31        int getMatchedIndex(int Obj, int index);
     32        bool isFull();
     33        bool isEmpty();
     34        void empty();
     35        void printMatching();
    3636};
    3737
  • cpp/tests/similarity-tests.txt

    r984 r1044  
    1111TESTNAME:parts weight
    1212arg:similarity.gen
    13 arg:0
     13arg:hungarian
    1414arg:1
    1515arg:0
     
    2222TESTNAME:degrees weight
    2323arg:similarity.gen
    24 arg:0
     24arg:hungarian
    2525arg:0
    2626arg:1
     
    3333TESTNAME:neurons weight
    3434arg:similarity.gen
    35 arg:0
     35arg:hungarian
    3636arg:0
    3737arg:0
     
    4444TESTNAME:distances weight greedy
    4545arg:similarity.gen
    46 arg:1
     46arg:greedy
    4747arg:0
    4848arg:0
     
    5555TESTNAME:all weights greedy
    5656arg:similarity.gen
    57 arg:1
     57arg:greedy
    5858arg:1
    5959arg:1
     
    6666TESTNAME:all weights fixed z greedy
    6767arg:similarity.gen
    68 arg:1
     68arg:greedy
    6969arg:1
    7070arg:1
     
    7777TESTNAME:distances weight hungarian
    7878arg:similarity.gen
    79 arg:0
     79arg:hungarian
    8080arg:0
    8181arg:0
     
    8888TESTNAME:all weights hungarian
    8989arg:similarity.gen
    90 arg:0
     90arg:hungarian
    9191arg:1
    9292arg:1
     
    9999TESTNAME:all weights fixed z hungarian
    100100arg:similarity.gen
    101 arg:0
     101arg:hungarian
    102102arg:1
    103103arg:1
     
    107107out:*INSERTPLATFORMDEPENDENTFILE*:similarity_goals/all_weights_fixed_z_hungarian
    108108RUNTEST
     109
     110TESTNAME:distribution
     111arg:similarity.gen
     112arg:distribution
     113arg:5
     114arg:128
     115arg:100000
     116out:*INSERTPLATFORMDEPENDENTFILE*:similarity_goals/distribution
     117RUNTEST
Note: See TracChangeset for help on using the changeset viewer.