|| || || || || || || ||

---

SearchResult.h

Go to the documentation of this file.

#ifndef Impala_Core_Trec_SearchResult_h
#define Impala_Core_Trec_SearchResult_h

#include "Core/Trec/SearchJudge.h"

namespace Impala
{
namespace Core
{
namespace Trec
{


class SearchResult
{
public:

    SearchResult()
    {
    }

    SearchResult(std::string fileName)
    {
        Load(fileName);
    }

    SearchResult(std::string topic, std::vector<std::string> shots)
    {
        mTopic = topic;
        mShot = shots;
    }

    void
    Load(std::string fileName)
    {
        File f(fileName, "r");
        if (! f.Valid())
            return;
        Util::StringParser first(f.ReadLine(true));
        first.Advance('"');
        mTopic = first.GetString();
        f.ReadLine(true); // skip second line
        while (! f.Eof())
        {
            std::string line = f.ReadLine(true);
            if (! line[0])
                continue;
            Util::StringParser p(line);
            std::string str = p.GetString(' ', false);
            if (str != std::string("<item"))
                continue;
            p.Advance('"', 3);
            str = p.GetString();
            mShot.push_back(str);
        }
    }

    void
    Load(std::string topic, std::vector<std::string> shots)
    {
        mShot.clear();
        mTopic = topic;
        mShot = shots;
    }

    void
    Judge(SearchJudge* theJudge, bool verbose = false)
    {
        mJudgement.clear();
        mHits.clear();
        mPrecision.clear();
        int nrRelevant = theJudge->GetNrRelevant(mTopic);
        int hits = 0;
        double accumPrecision = 0;
        for (int i=0 ; i<mShot.size() ; i++)
        {
            int judgement = theJudge->Judge(mTopic, mShot[i]);
            int nr = i+1;
            if (judgement == 1)
            {
                if (verbose && (nr <= 10))
                    std::cout << "    Hit at " << nr << std::endl;
                hits++;
                accumPrecision += (double) hits / nr;
            }
            double precision = (double) hits / nr;
            if (verbose && (nr == 10))
                std::cout << "Hits at 10 : " << hits << ", precision : "
                          << precision << std::endl;
            if (verbose && (nr == 30))
                std::cout << "Hits at 30 : " << hits << ", precision : "
                          << precision << std::endl;
            if (verbose && (nr == 100))
                std::cout << "Hits at 100 : " << hits << ", precision : "
                          << precision << std::endl;
            if (verbose && (nr == 1000))
                std::cout << "Hits at 1000 : " << hits << ", precision : "
                          << precision << std::endl;
            mJudgement.push_back(judgement);
            mHits.push_back(hits);
            mPrecision.push_back(precision);
        }
        mAp = accumPrecision / nrRelevant;
        if (verbose)
            std::cout << "average precision : " << mAp << std::endl;
    }

    double
    GetAveragePrecision()
    {
        return mAp;
    }

    int
    NrElements()
    {
        return mShot.size();
    }

    std::string
    GetShot(int idx)
    {
        return mShot[idx];
    }

    int
    GetJudgement(int idx)
    {
        return mJudgement[idx];
    }

    int
    GetHits(int idx)
    {
        return mHits[idx];
    }

    double
    GetPrecision(int idx)
    {
        return mPrecision[idx];
    }

    std::string
    Describe(int idx)
    {
        std::string jString("no judgement");
        if (mJudgement[idx] == 0)
            jString = std::string("not relevant");
        if (mJudgement[idx] == 1)
            jString = std::string("is relevant");
        return std::string("nr ") + MakeString(idx+1) + " " + mShot[idx] + ", "
            + jString + ", hits = " + MakeString(mHits[idx])
            + ", precision = " + MakeString(mPrecision[idx]);
    }

private:

    std::string              mTopic;
    std::vector<std::string> mShot;
    std::vector<int>         mJudgement;
    std::vector<int>         mHits;
    std::vector<double>      mPrecision;
    double                   mAp;

};

} // namespace Trec
} // namespace Core
} // namespace Impala

#endif

---