LCOV - code coverage report
Current view: top level - home/blackburn/Work/tapkee/include/tapkee - chain_interface.hpp (source / functions) Hit Total Coverage
Test: clean.info Lines: 65 65 100.0 %
Date: 2013-05-24 Functions: 70 70 100.0 %
Branches: 19 38 50.0 %

           Branch data     Line data    Source code
       1                 :            : /* This software is distributed under BSD 3-clause license (see LICENSE file).
       2                 :            :  *
       3                 :            :  * Copyright (c) 2012-2013 Sergey Lisitsyn
       4                 :            :  */
       5                 :            : 
       6                 :            : #ifndef TAPKEE_CHAIN_H_
       7                 :            : #define TAPKEE_CHAIN_H_
       8                 :            : 
       9                 :            : /* Tapkee includes */
      10                 :            : #include <tapkee/embed.hpp>
      11                 :            : #include <tapkee/callbacks/dummy_callbacks.hpp>
      12                 :            : #include <tapkee/callbacks/eigen_callbacks.hpp>
      13                 :            : /* End of Tapkee includes */
      14                 :            : 
      15                 :            : namespace tapkee
      16                 :            : {
      17                 :            : 
      18                 :            : namespace tapkee_internal
      19                 :            : {
      20                 :            :         template<class KernelCallback, class DistanceCallback, class FeaturesCallback>
      21                 :         15 :         class CallbacksInitializedState
      22                 :            :         {
      23                 :            :         public:
      24                 :         15 :                 CallbacksInitializedState(const ParametersSet& params, const KernelCallback& k,
      25                 :            :                                                                   const DistanceCallback& d, const FeaturesCallback& f) :
      26                 :         15 :                         parameters(params), kernel(k), distance(d), features(f) { }
      27                 :            : 
      28                 :            :                 /** Constructs an embedding using the data represented by the 
      29                 :            :                  * begin and end iterators.
      30                 :            :                  *
      31                 :            :                  * @param begin an iterator that points to the beginning of data container
      32                 :            :                  * @param end an iterator that points to the end of data container
      33                 :            :                  */
      34                 :            :                 template<class RandomAccessIterator>
      35                 :         15 :                 TapkeeOutput embedRange(RandomAccessIterator begin, RandomAccessIterator end) const
      36                 :            :                 {
      37 [ +  - ][ +  - ]:         15 :                         return tapkee::embed(begin,end,kernel,distance,features,parameters);
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
                 [ +  - ]
      38                 :            :                 }
      39                 :            : 
      40                 :            :                 /** Constructs an embedding using the data represented by the container. 
      41                 :            :                  *
      42                 :            :                  * @param container a container that supports begin() and end() methods 
      43                 :            :                  *                  to get corresponding iterators
      44                 :            :                  */
      45                 :            :                 template<class Container>
      46                 :            :                 TapkeeOutput embedUsing(const Container& container) const
      47                 :            :                 {
      48                 :            :                         return embedRange(container.begin(),container.end());
      49                 :            :                 }
      50                 :            :         private:
      51                 :            :                 ParametersSet parameters;
      52                 :            :                 KernelCallback kernel;
      53                 :            :                 DistanceCallback distance;
      54                 :            :                 FeaturesCallback features;
      55                 :            :         };
      56                 :            : 
      57                 :            :         template<class KernelCallback, class DistanceCallback>
      58                 :          6 :         class KernelAndDistanceInitializedState
      59                 :            :         {
      60                 :            :         public:
      61                 :          6 :                 KernelAndDistanceInitializedState(const ParametersSet& params, const KernelCallback& k, const DistanceCallback& d) :
      62                 :          6 :                         parameters(params), kernel(k), distance(d) { }
      63                 :            : 
      64                 :            :                 /** Sets features callback.
      65                 :            :                  *
      66                 :            :                  * @param callback a callback that implements the
      67                 :            :                  *        @code vector(const RandomAccessIterator::value_type&, DenseVector&) @endcode
      68                 :            :                  *        member function which is used to obtain the feature vector pointed by the 
      69                 :            :                  *        first argument.
      70                 :            :                  */
      71                 :            :                 template<class FeaturesCallback>
      72                 :          6 :                 CallbacksInitializedState<KernelCallback,DistanceCallback,FeaturesCallback> withFeatures(const FeaturesCallback& features) const
      73                 :          6 :                 { return CallbacksInitializedState<KernelCallback,DistanceCallback,FeaturesCallback>(parameters,kernel,distance,features); }
      74                 :            :                 
      75                 :            :                 /** Constructs an embedding using the data represented by the 
      76                 :            :                  * begin and end iterators.
      77                 :            :                  *
      78                 :            :                  * @param begin an iterator that points to the beginning of data container
      79                 :            :                  * @param end an iterator that points to the end of data container
      80                 :            :                  */
      81                 :            :                 template<class RandomAccessIterator>
      82                 :          2 :                 TapkeeOutput embedRange(RandomAccessIterator begin, RandomAccessIterator end) const
      83                 :            :                 {
      84                 :            :                         return (*this).withFeatures(dummy_features_callback<typename RandomAccessIterator::value_type>())
      85         [ +  - ]:          2 :                                                   .embedRange(begin,end);
      86                 :            :                 }
      87                 :            : 
      88                 :            :                 /** Constructs an embedding using the data represented by the container. 
      89                 :            :                  *
      90                 :            :                  * @param container a container that supports begin() and end() methods 
      91                 :            :                  *                  to get corresponding iterators
      92                 :            :                  */
      93                 :            :                 template<class Container>
      94                 :            :                 TapkeeOutput embedUsing(const Container& container) const
      95                 :            :                 {
      96                 :            :                         return embedRange(container.begin(),container.end());
      97                 :            :                 }
      98                 :            :         private:
      99                 :            :                 ParametersSet parameters;
     100                 :            :                 KernelCallback kernel;
     101                 :            :                 DistanceCallback distance;
     102                 :            :         };
     103                 :            : 
     104                 :            :         template<class KernelCallback, class FeaturesCallback>
     105                 :          5 :         class KernelAndFeaturesInitializedState
     106                 :            :         {
     107                 :            :         public:
     108                 :          5 :                 KernelAndFeaturesInitializedState(const ParametersSet& params, const KernelCallback& k, const FeaturesCallback& f) :
     109                 :          5 :                         parameters(params), kernel(k), features(f) { }
     110                 :            : 
     111                 :            :                 /** Sets distance callback.
     112                 :            :                  *
     113                 :            :                  * @param callback a callback that implements the
     114                 :            :                  *        @code distance(const RandomAccessIterator::value_type&, const RandomAccessIterator::value_type&) @endcode
     115                 :            :                  *        member function which is used to compute distance (dissimilarity) between two objects 
     116                 :            :                  *        pointed by the first and the second arguments.
     117                 :            :                  */
     118                 :            :                 template<class DistanceCallback>
     119                 :          5 :                 CallbacksInitializedState<KernelCallback,DistanceCallback,FeaturesCallback> withDistance(const DistanceCallback& distance) const
     120                 :          5 :                 { return CallbacksInitializedState<KernelCallback,DistanceCallback,FeaturesCallback>(parameters,kernel,distance,features); }
     121                 :            : 
     122                 :            :                 /** Constructs an embedding using the data represented by the 
     123                 :            :                  * begin and end iterators.
     124                 :            :                  *
     125                 :            :                  * @param begin an iterator that points to the beginning of data container
     126                 :            :                  * @param end an iterator that points to the end of data container
     127                 :            :                  */
     128                 :            :                 template<class RandomAccessIterator>
     129                 :          2 :                 TapkeeOutput embedRange(RandomAccessIterator begin, RandomAccessIterator end) const
     130                 :            :                 {
     131                 :            :                         return (*this).withDistance(dummy_distance_callback<typename RandomAccessIterator::value_type>())
     132         [ +  - ]:          2 :                                                   .embedRange(begin,end);
     133                 :            :                 }
     134                 :            : 
     135                 :            :                 /** Constructs an embedding using the data represented by the container. 
     136                 :            :                  *
     137                 :            :                  * @param container a container that supports begin() and end() methods 
     138                 :            :                  *                  to get corresponding iterators
     139                 :            :                  */
     140                 :            :                 template<class Container>
     141                 :            :                 TapkeeOutput embedUsing(const Container& container) const
     142                 :            :                 {
     143                 :            :                         return embedRange(container.begin(),container.end());
     144                 :            :                 }
     145                 :            :         private:
     146                 :            :                 ParametersSet parameters;
     147                 :            :                 KernelCallback kernel;
     148                 :            :                 FeaturesCallback features;
     149                 :            :         };
     150                 :            : 
     151                 :            :         /**
     152                 :            :          *
     153                 :            :          *
     154                 :            :          *
     155                 :            :          */
     156                 :            :         template<class DistanceCallback, class FeaturesCallback>
     157                 :          4 :         class DistanceAndFeaturesInitializedState
     158                 :            :         {
     159                 :            :         public:
     160                 :          4 :                 DistanceAndFeaturesInitializedState(const ParametersSet& params, const DistanceCallback& d, const FeaturesCallback& f) :
     161                 :          4 :                         parameters(params), distance(d), features(f) { }
     162                 :            : 
     163                 :            :                 /** Sets kernel callback.
     164                 :            :                  *
     165                 :            :                  * @param callback a callback that implements the 
     166                 :            :                  *        @code kernel(const RandomAccessIterator::value_type&, const RandomAccessIterator::value_type&) @endcode
     167                 :            :                  *        member function which is used to compute kernel value (similarity) between two objects
     168                 :            :                  *        pointed by the first and the second arguments.
     169                 :            :                  */
     170                 :            :                 template<class KernelCallback>
     171                 :          4 :                 CallbacksInitializedState<KernelCallback,DistanceCallback,FeaturesCallback> withKernel(const KernelCallback& kernel) const
     172                 :          4 :                 { return CallbacksInitializedState<KernelCallback,DistanceCallback,FeaturesCallback>(parameters,kernel,distance,features); }
     173                 :            : 
     174                 :            :                 /** Constructs an embedding using the data represented by the 
     175                 :            :                  * begin and end iterators.
     176                 :            :                  *
     177                 :            :                  * @param begin an iterator that points to the beginning of data container
     178                 :            :                  * @param end an iterator that points to the end of data container
     179                 :            :                  */
     180                 :            :                 template<class RandomAccessIterator>
     181                 :          2 :                 TapkeeOutput embedRange(RandomAccessIterator begin, RandomAccessIterator end) const
     182                 :            :                 {
     183                 :            :                         return (*this).withKernel(dummy_kernel_callback<typename RandomAccessIterator::value_type>())
     184         [ +  - ]:          2 :                                                   .embedRange(begin,end);
     185                 :            :                 }
     186                 :            : 
     187                 :            :                 /** Constructs an embedding using the data represented by the container. 
     188                 :            :                  *
     189                 :            :                  * @param container a container that supports begin() and end() methods 
     190                 :            :                  *                  to get corresponding iterators
     191                 :            :                  */
     192                 :            :                 template<class Container>
     193                 :            :                 TapkeeOutput embedUsing(const Container& container) const
     194                 :            :                 {
     195                 :            :                         return embedRange(container.begin(),container.end());
     196                 :            :                 }
     197                 :            :         private:
     198                 :            :                 ParametersSet parameters;
     199                 :            :                 DistanceCallback distance;
     200                 :            :                 FeaturesCallback features;
     201                 :            :         };
     202                 :            : 
     203                 :            :         template<class KernelCallback>
     204                 :          5 :         class KernelFirstInitializedState
     205                 :            :         {
     206                 :            :         public:
     207                 :          5 :                 KernelFirstInitializedState(const ParametersSet& params, const KernelCallback& callback) :
     208                 :          5 :                         parameters(params), kernel(callback) { }
     209                 :            : 
     210                 :            :                 /** Sets distance callback.
     211                 :            :                  *
     212                 :            :                  * @param callback a callback that implements the
     213                 :            :                  *        @code distance(const RandomAccessIterator::value_type&, const RandomAccessIterator::value_type&) @endcode
     214                 :            :                  *        member function which is used to compute distance (dissimilarity) between two objects 
     215                 :            :                  *        pointed by the first and the second arguments.
     216                 :            :                  */
     217                 :            :                 template<class DistanceCallback>
     218                 :          3 :                 KernelAndDistanceInitializedState<KernelCallback,DistanceCallback> withDistance(const DistanceCallback& callback) const
     219                 :          3 :                 { return KernelAndDistanceInitializedState<KernelCallback,DistanceCallback>(parameters,kernel,callback); }
     220                 :            : 
     221                 :            :                 /** Sets features callback.
     222                 :            :                  *
     223                 :            :                  * @param callback a callback that implements the
     224                 :            :                  *        @code vector(const RandomAccessIterator::value_type&, DenseVector&) @endcode
     225                 :            :                  *        member function which is used to obtain the feature vector pointed by the 
     226                 :            :                  *        first argument.
     227                 :            :                  */
     228                 :            :                 template<class FeaturesCallback>
     229                 :          2 :                 KernelAndFeaturesInitializedState<KernelCallback,FeaturesCallback> withFeatures(const FeaturesCallback& callback) const
     230                 :          2 :                 { return KernelAndFeaturesInitializedState<KernelCallback,FeaturesCallback>(parameters,kernel,callback); }
     231                 :            : 
     232                 :            :                 /** Constructs an embedding using the data represented by the 
     233                 :            :                  * begin and end iterators.
     234                 :            :                  *
     235                 :            :                  * @param begin an iterator that points to the beginning of data container
     236                 :            :                  * @param end an iterator that points to the end of data container
     237                 :            :                  */
     238                 :            :                 template<class RandomAccessIterator>
     239                 :          1 :                 TapkeeOutput embedRange(RandomAccessIterator begin, RandomAccessIterator end) const
     240                 :            :                 {
     241                 :            :                         return (*this).withDistance(dummy_distance_callback<typename RandomAccessIterator::value_type>())
     242                 :            :                                                   .withFeatures(dummy_features_callback<typename RandomAccessIterator::value_type>())
     243 [ +  - ][ +  - ]:          1 :                                                   .embedRange(begin,end);
                 [ +  - ]
     244                 :            :                 }
     245                 :            : 
     246                 :            :                 /** Constructs an embedding using the data represented by the container. 
     247                 :            :                  *
     248                 :            :                  * @param container a container that supports begin() and end() methods 
     249                 :            :                  *                  to get corresponding iterators
     250                 :            :                  */
     251                 :            :                 template<class Container>
     252                 :            :                 TapkeeOutput embedUsing(const Container& container) const
     253                 :            :                 {
     254                 :            :                         return embedRange(container.begin(),container.end());
     255                 :            :                 }
     256                 :            :         private:
     257                 :            :                 ParametersSet parameters;
     258                 :            :                 KernelCallback kernel;
     259                 :            :         };
     260                 :            : 
     261                 :            :         template<class DistanceCallback>
     262                 :          5 :         class DistanceFirstInitializedState
     263                 :            :         {
     264                 :            :         public:
     265                 :          5 :                 DistanceFirstInitializedState(const ParametersSet& params, const DistanceCallback& callback) :
     266                 :          5 :                         parameters(params), distance(callback) { }
     267                 :            : 
     268                 :            :                 /** Sets kernel callback.
     269                 :            :                  *
     270                 :            :                  * @param callback a callback that implements the 
     271                 :            :                  *        @code kernel(const RandomAccessIterator::value_type&, const RandomAccessIterator::value_type&) @endcode
     272                 :            :                  *        member function which is used to compute kernel value (similarity) between two objects
     273                 :            :                  *        pointed by the first and the second arguments.
     274                 :            :                  */
     275                 :            :                 template<class KernelCallback>
     276                 :          3 :                 KernelAndDistanceInitializedState<KernelCallback,DistanceCallback> withKernel(const KernelCallback& callback) const
     277                 :          3 :                 { return KernelAndDistanceInitializedState<KernelCallback,DistanceCallback>(parameters,callback,distance); }
     278                 :            : 
     279                 :            :                 /** Sets features callback.
     280                 :            :                  *
     281                 :            :                  * @param callback a callback that implements the
     282                 :            :                  *        @code vector(const RandomAccessIterator::value_type&, DenseVector&) @endcode
     283                 :            :                  *        member function which is used to obtain the feature vector pointed by the 
     284                 :            :                  *        first argument.
     285                 :            :                  */
     286                 :            :                 template<class FeaturesCallback>
     287                 :          2 :                 DistanceAndFeaturesInitializedState<DistanceCallback,FeaturesCallback> withFeatures(const FeaturesCallback& callback) const
     288                 :          2 :                 { return DistanceAndFeaturesInitializedState<DistanceCallback,FeaturesCallback>(parameters,distance,callback); }
     289                 :            : 
     290                 :            :                 /** Constructs an embedding using the data represented by the 
     291                 :            :                  * begin and end iterators.
     292                 :            :                  *
     293                 :            :                  * @param begin an iterator that points to the beginning of data container
     294                 :            :                  * @param end an iterator that points to the end of data container
     295                 :            :                  */
     296                 :            :                 template<class RandomAccessIterator>
     297                 :          1 :                 TapkeeOutput embedRange(RandomAccessIterator begin, RandomAccessIterator end) const
     298                 :            :                 {
     299                 :            :                         return (*this).withKernel(dummy_kernel_callback<typename RandomAccessIterator::value_type>())
     300                 :            :                                                   .withFeatures(dummy_features_callback<typename RandomAccessIterator::value_type>())
     301 [ +  - ][ +  - ]:          1 :                                                   .embedRange(begin,end);
                 [ +  - ]
     302                 :            :                 }
     303                 :            : 
     304                 :            :                 /** Constructs an embedding using the data represented by the container. 
     305                 :            :                  *
     306                 :            :                  * @param container a container that supports begin() and end() methods 
     307                 :            :                  *                  to get corresponding iterators
     308                 :            :                  */
     309                 :            :                 template<class Container>
     310                 :            :                 TapkeeOutput embedUsing(const Container& container) const
     311                 :            :                 {
     312                 :            :                         return embedRange(container.begin(),container.end());
     313                 :            :                 }
     314                 :            :         private:
     315                 :            :                 ParametersSet parameters;
     316                 :            :                 DistanceCallback distance;
     317                 :            :         };
     318                 :            : 
     319                 :            :         template<class FeaturesCallback>
     320                 :          5 :         class FeaturesFirstInitializedState
     321                 :            :         {
     322                 :            :         public:
     323                 :          5 :                 FeaturesFirstInitializedState(const ParametersSet& params, const FeaturesCallback& callback) :
     324                 :          5 :                         parameters(params), features(callback) { }
     325                 :            : 
     326                 :            :                 /** Sets kernel callback.
     327                 :            :                  *
     328                 :            :                  * @param callback a callback that implements the 
     329                 :            :                  *        @code kernel(const RandomAccessIterator::value_type&, const RandomAccessIterator::value_type&) @endcode
     330                 :            :                  *        member function which is used to compute kernel value (similarity) between two objects
     331                 :            :                  *        pointed by the first and the second arguments.
     332                 :            :                  */
     333                 :            :                 template<class KernelCallback>
     334                 :          3 :                 KernelAndFeaturesInitializedState<KernelCallback,FeaturesCallback> withKernel(const KernelCallback& callback) const
     335                 :          3 :                 { return KernelAndFeaturesInitializedState<KernelCallback,FeaturesCallback>(parameters,callback,features); }
     336                 :            : 
     337                 :            :                 /** Sets distance callback.
     338                 :            :                  *
     339                 :            :                  * @param callback a callback that implements the
     340                 :            :                  *        @code distance(const RandomAccessIterator::value_type&, const RandomAccessIterator::value_type&) @endcode
     341                 :            :                  *        member function which is used to compute distance (dissimilarity) between two objects 
     342                 :            :                  *        pointed by the first and the second arguments.
     343                 :            :                  */
     344                 :            :                 template<class DistanceCallback>
     345                 :          2 :                 DistanceAndFeaturesInitializedState<DistanceCallback,FeaturesCallback> withDistance(const DistanceCallback& callback) const
     346                 :          2 :                 { return DistanceAndFeaturesInitializedState<DistanceCallback,FeaturesCallback>(parameters,callback,features); }
     347                 :            : 
     348                 :            :                 /** Constructs an embedding using the data represented by the 
     349                 :            :                  * begin and end iterators.
     350                 :            :                  *
     351                 :            :                  * @param begin an iterator that points to the beginning of data container
     352                 :            :                  * @param end an iterator that points to the end of data container
     353                 :            :                  */
     354                 :            :                 template<class RandomAccessIterator>
     355                 :          1 :                 TapkeeOutput embedRange(RandomAccessIterator begin, RandomAccessIterator end) const
     356                 :            :                 {
     357                 :            :                         return (*this).withKernel(dummy_kernel_callback<typename RandomAccessIterator::value_type>())
     358                 :            :                                                   .withDistance(dummy_distance_callback<typename RandomAccessIterator::value_type>())
     359 [ +  - ][ +  - ]:          1 :                                                   .embedRange(begin,end);
                 [ +  - ]
     360                 :            :                 }
     361                 :            : 
     362                 :            :                 /** Constructs an embedding using the data represented by the container. 
     363                 :            :                  *
     364                 :            :                  * @param container a container that supports begin() and end() methods 
     365                 :            :                  *                  to get corresponding iterators
     366                 :            :                  */
     367                 :            :                 template<class Container>
     368                 :            :                 TapkeeOutput embedUsing(const Container& container) const
     369                 :            :                 {
     370                 :            :                         return embedRange(container.begin(),container.end());
     371                 :            :                 }
     372                 :            :         private:
     373                 :            :                 ParametersSet parameters;
     374                 :            :                 FeaturesCallback features;
     375                 :            :         };
     376                 :            : 
     377                 :         15 :         class ParametersInitializedState
     378                 :            :         {
     379                 :            :         public:
     380                 :         15 :                 ParametersInitializedState(const ParametersSet& that) : parameters(that) { }
     381                 :            :                 ParametersInitializedState(const ParametersInitializedState&);
     382                 :            :                 ParametersInitializedState& operator=(const ParametersInitializedState&);
     383                 :            : 
     384                 :            :                 /** Sets kernel callback.
     385                 :            :                  *
     386                 :            :                  * @param callback a callback that implements the 
     387                 :            :                  *        @code kernel(const RandomAccessIterator::value_type&, const RandomAccessIterator::value_type&) @endcode
     388                 :            :                  *        member function which is used to compute kernel value (similarity) between two objects
     389                 :            :                  *        pointed by the first and the second arguments.
     390                 :            :                  */
     391                 :            :                 template<class KernelCallback> 
     392                 :          5 :                 KernelFirstInitializedState<KernelCallback> withKernel(const KernelCallback& callback) const
     393                 :          5 :                 { return KernelFirstInitializedState<KernelCallback>(parameters,callback); }
     394                 :            : 
     395                 :            :                 /** Sets distance callback.
     396                 :            :                  *
     397                 :            :                  * @param callback a callback that implements the
     398                 :            :                  *        @code distance(const RandomAccessIterator::value_type&, const RandomAccessIterator::value_type&) @endcode
     399                 :            :                  *        member function which is used to compute distance (dissimilarity) between two objects 
     400                 :            :                  *        pointed by the first and the second arguments.
     401                 :            :                  */
     402                 :            :                 template<class DistanceCallback>
     403                 :          5 :                 DistanceFirstInitializedState<DistanceCallback> withDistance(const DistanceCallback& callback) const
     404                 :          5 :                 { return DistanceFirstInitializedState<DistanceCallback>(parameters,callback); }
     405                 :            : 
     406                 :            :                 /** Sets features callback.
     407                 :            :                  *
     408                 :            :                  * @param callback a callback that implements the
     409                 :            :                  *        @code vector(const RandomAccessIterator::value_type&, DenseVector&) @endcode
     410                 :            :                  *        member function which is used to obtain the feature vector pointed by the 
     411                 :            :                  *        first argument.
     412                 :            :                  */
     413                 :            :                 template<class FeaturesCallback>
     414                 :          5 :                 FeaturesFirstInitializedState<FeaturesCallback> withFeatures(const FeaturesCallback& callback) const
     415                 :          5 :                 { return FeaturesFirstInitializedState<FeaturesCallback>(parameters,callback); }
     416                 :            : 
     417                 :            :                 /** Constructs an embedding using the data represented
     418                 :            :                  * by the feature matrix. Uses linear kernel (dot product)
     419                 :            :                  * and euclidean distance.
     420                 :            :                  * 
     421                 :            :                  * @param matrix matrix that contains feature vectors column-wise
     422                 :            :                  */
     423                 :            :                 TapkeeOutput embedUsing(const DenseMatrix& matrix) const
     424                 :            :                 {
     425                 :            :                         std::vector<IndexType> indices(matrix.cols());
     426                 :            :                         for (IndexType i=0; i<matrix.cols(); i++) indices[i] = i;
     427                 :            :                         eigen_kernel_callback kcb(matrix);
     428                 :            :                         eigen_distance_callback dcb(matrix);
     429                 :            :                         eigen_features_callback fcb(matrix);
     430                 :            :                         return tapkee::embed(indices.begin(),indices.end(),kcb,dcb,fcb,parameters);
     431                 :            :                 }
     432                 :            :         private:
     433                 :            :                 ParametersSet parameters;
     434                 :            :         };
     435                 :            : } /* End of namespace tapkee_internal */
     436                 :            : 
     437                 :            : struct initialize
     438                 :            : {
     439                 :            :         /** Constructor that is the first required 
     440                 :            :          * method in the call chain.
     441                 :            :          */
     442                 :         15 :         initialize() 
     443                 :            :         {
     444                 :         15 :         }
     445                 :            : 
     446                 :            :         /** The second required method in the call chain. Returns 
     447                 :            :          * an instance representing a state with initialized parameters.
     448                 :            :          *
     449                 :            :          * In the chain this method's call is followed by any of 
     450                 :            :          * * @ref tapkee_internal::ParametersInitializedState::embedUsing 
     451                 :            :          * * @ref tapkee_internal::ParametersInitializedState::withKernel
     452                 :            :          * * @ref tapkee_internal::ParametersInitializedState::withDistance
     453                 :            :          * * @ref tapkee_internal::ParametersInitializedState::withFeatures
     454                 :            :          * 
     455                 :            :          * @param parameters a set of parameters formed from keywords assigned
     456                 :            :          *                   to values 
     457                 :            :          */
     458                 :         15 :         tapkee_internal::ParametersInitializedState withParameters(const ParametersSet& parameters) const
     459                 :            :         {
     460                 :         15 :                 return tapkee_internal::ParametersInitializedState(parameters);
     461                 :            :         }
     462                 :            : };
     463                 :            : 
     464                 :            : } /* End of namespace tapkee */
     465                 :            : 
     466                 :            : #endif
     467                 :            : 

Generated by: LCOV version 1.9