types.hpp

#pragma once
 
#include <string>
#include <vector>
#include <memory>
 
namespace svm_classifier {
 
    enum class KernelType {
        LINEAR,      
        RBF,         
        POLYNOMIAL,  
        SIGMOID      
    };
 
    enum class MulticlassStrategy {
        ONE_VS_REST,  
        ONE_VS_ONE    
    };
 
    enum class SVMLibrary {
        LIBLINEAR,   
        LIBSVM       
    };
 
    enum class TrainingStatus {
        SUCCESS,
        INVALID_PARAMETERS,
        INSUFFICIENT_DATA,
        MEMORY_ERROR,
        CONVERGENCE_ERROR
    };
 
    struct PredictionResult {
        std::vector<int> predictions;           
        std::vector<std::vector<double>> probabilities; 
        std::vector<std::vector<double>> decision_values; 
        bool has_probabilities = false;        
    };
 
    struct TrainingMetrics {
        double training_time = 0.0;           
        int support_vectors = 0;              
        int iterations = 0;                   
        double objective_value = 0.0;         
        TrainingStatus status = TrainingStatus::SUCCESS;
    };
 
    struct EvaluationMetrics {
        double accuracy = 0.0;                
        double precision = 0.0;               
        double recall = 0.0;                  
        double f1_score = 0.0;                
        std::vector<std::vector<int>> confusion_matrix; 
    };
 
    inline std::string kernel_type_to_string(KernelType kernel)
    {
        switch (kernel) {
            case KernelType::LINEAR: return "linear";
            case KernelType::RBF: return "rbf";
            case KernelType::POLYNOMIAL: return "polynomial";
            case KernelType::SIGMOID: return "sigmoid";
            default: return "unknown";
        }
    }
 
    inline KernelType string_to_kernel_type(const std::string& kernel_str)
    {
        if (kernel_str == "linear") return KernelType::LINEAR;
        if (kernel_str == "rbf") return KernelType::RBF;
        if (kernel_str == "polynomial" || kernel_str == "poly") return KernelType::POLYNOMIAL;
        if (kernel_str == "sigmoid") return KernelType::SIGMOID;
        throw std::invalid_argument("Unknown kernel type: " + kernel_str);
    }
 
    inline std::string multiclass_strategy_to_string(MulticlassStrategy strategy)
    {
        switch (strategy) {
            case MulticlassStrategy::ONE_VS_REST: return "ovr";
            case MulticlassStrategy::ONE_VS_ONE: return "ovo";
            default: return "unknown";
        }
    }
 
    inline MulticlassStrategy string_to_multiclass_strategy(const std::string& strategy_str)
    {
        if (strategy_str == "ovr" || strategy_str == "one_vs_rest") {
            return MulticlassStrategy::ONE_VS_REST;
        }
        if (strategy_str == "ovo" || strategy_str == "one_vs_one") {
            return MulticlassStrategy::ONE_VS_ONE;
        }
        throw std::invalid_argument("Unknown multiclass strategy: " + strategy_str);
    }
 
    inline SVMLibrary get_svm_library(KernelType kernel)
    {
        return (kernel == KernelType::LINEAR) ? SVMLibrary::LIBLINEAR : SVMLibrary::LIBSVM;
    }
 
} // namespace svm_classifier