Шаблонная функция которая будет вычислять TF-IDF

#include <vector>
#include <string>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <map>
 
 
 
using namespace std;
 
template <typename Documents, typename Term>
vector <double> ComputeTfIdfs(const  Documents& documents, const  Term& term_query) {
    map<vector<Term>, double> TF;
    vector <double> tf_idf;
   for (const auto& document : documents) {
        if (count(document.begin(), document.end(), term_query) != 0) {
                TF[document] += 1.0 / static_cast<double>(document.size());
        }
    }
    double IDF = log(static_cast<double>(documents.size()) / static_cast<double>(TF.size()));
    for (const auto& document : documents) {
        tf_idf.push_back(IDF * TF[document]);
    }
        
    return tf_idf;
}

template <typename Documents, typename Term>
vector <double> ComputeTfIdfs(const  Documents& documents, const  Term& term_query) {
    vector<double> tf(documents.size()) , tf_idf(documents.size());
    unsigned query_in_doc_c{}, query_count{};
    for (auto it = documents.begin(); it!=documents.end(); ++it ) {
        query_count = count(document.begin(), document.end(), term_query);
        docs_have_query += bool(query_count);
        *tf= query_count  / static_cast<double>(document.size());
    }
    double IDF = log(documents.size() / static_cast<double>(docs_have_query);
    for (auto i = 0; i<=documents.size(); ++i ) {
        tf_idf[i] = IDF * tf[i];
    }
    return tf_idf;
}

int main() {
    const vector<vector<string>> documents = {
        {"белый"s, "кот"s, "и"s, "модный"s, "ошейник"s},
        {"пушистый"s, "кот"s, "пушистый"s, "хвост"s},
        {"ухоженный"s, "пёс"s, "выразительные"s, "глаза"s},
    };
    const auto& tf_idfs = ComputeTfIdfs(documents, "кот"s);
    for (const double tf_idf : tf_idfs) {
        cout << tf_idf << " "s;
    }
    cout << endl;
}

template <typename Documents, typename Term>
vector <double> ComputeTfIdfs(const  Documents& documents, const  Term& term_query) {
    vector<double> tf(documents.size()) , tf_idf(documents.size());
    unsigned query_in_doc_c{}, query_count{};
    for (auto i = 0; i<documents.size(); ++i ) {
        query_count = count(documents[i].begin(), documents[i].end(), term_query);
        query_in_doc_c += bool(query_count);
        tf[i] = query_count  / static_cast<double>(documents[i].size());
    }
    double IDF = log(documents.size() / static_cast<double>(query_in_doc_c ? query_in_doc_c : 1));
    for (auto i = 0; i<documents.size(); ++i )
        tf_idf[i] = IDF * tf[i];
    return tf_idf;
}

template <typename Documents, typename Term>
vector <double> ComputeTfIdfs(const  Documents& documents, const  Term& term_query) {
    vector<double> tf, tf_idf;
    unsigned query_in_doc_c{}, query_count{};
    for (auto document : documents ) {
        query_count = count(document.begin(), document.end(), term_query);
        query_in_doc_c += bool(query_count);
        tf.push_back(query_count  / static_cast<double>(document.size()));
    }
    double IDF = log(documents.size() / static_cast<double>(query_in_doc_c ? query_in_doc_c : 1));
    for (auto tf_i : tf)
        tf_idf.push_back(IDF * tf_i);
    return tf_idf;
}