inline operator T()
{
if (!valid)
{
throw wrong_parameter_error(invalidity_reason);
}
try
{
return getValue<T>();
}
catch (const missed_parameter_error&)
{
throw missed_parameter_error(parameter_name + " is missed");
}
}
ReturnResult embed(RandomAccessIterator begin, RandomAccessIterator end,
KernelCallback kernel_callback, DistanceCallback distance_callback,
FeatureVectorCallback feature_vector_callback, ParametersMap options)
{
ReturnResult return_result;
TAPKEE_METHOD method;
try
{
method = options[REDUCTION_METHOD].cast<TAPKEE_METHOD>();
}
catch (const anyimpl::bad_any_cast&)
{
throw wrong_parameter_error("Wrong method specified.");
}
#define CALL_IMPLEMENTATION(X) \
tapkee_internal::implementation<RandomAccessIterator,KernelCallback,DistanceCallback,FeatureVectorCallback,X>()(\
begin,end,kernel_callback,distance_callback,feature_vector_callback,options)
#define HANDLE_IMPLEMENTATION(X) \
case X: return_result = CALL_IMPLEMENTATION(X); break
try
{
LoggingSingleton::instance().message_info("Using " + tapkee_internal::get_method_name(method) + " method.");
switch (method)
{
HANDLE_IMPLEMENTATION(KERNEL_LOCALLY_LINEAR_EMBEDDING);
HANDLE_IMPLEMENTATION(KERNEL_LOCAL_TANGENT_SPACE_ALIGNMENT);
HANDLE_IMPLEMENTATION(DIFFUSION_MAP);
HANDLE_IMPLEMENTATION(MULTIDIMENSIONAL_SCALING);
HANDLE_IMPLEMENTATION(LANDMARK_MULTIDIMENSIONAL_SCALING);
HANDLE_IMPLEMENTATION(ISOMAP);
HANDLE_IMPLEMENTATION(LANDMARK_ISOMAP);
HANDLE_IMPLEMENTATION(NEIGHBORHOOD_PRESERVING_EMBEDDING);
HANDLE_IMPLEMENTATION(LINEAR_LOCAL_TANGENT_SPACE_ALIGNMENT);
HANDLE_IMPLEMENTATION(HESSIAN_LOCALLY_LINEAR_EMBEDDING);
HANDLE_IMPLEMENTATION(LAPLACIAN_EIGENMAPS);
HANDLE_IMPLEMENTATION(LOCALITY_PRESERVING_PROJECTIONS);
HANDLE_IMPLEMENTATION(PCA);
HANDLE_IMPLEMENTATION(KERNEL_PCA);
HANDLE_IMPLEMENTATION(RANDOM_PROJECTION);
HANDLE_IMPLEMENTATION(STOCHASTIC_PROXIMITY_EMBEDDING);
HANDLE_IMPLEMENTATION(PASS_THRU);
HANDLE_IMPLEMENTATION(FACTOR_ANALYSIS);
case UNKNOWN_METHOD:
throw wrong_parameter_error("unknown method");
break;
}
}
catch (const std::bad_alloc& ba)
{
LoggingSingleton::instance().message_error("Not enough memory available.");
throw not_enough_memory_error("Not enough memory");
}
#undef CALL_IMPLEMENTATION
#undef HANDLE_IMPLEMENTATION
return return_result;
};
