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

---

WeightedFeatureList.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_WeightedFeatureList_h
#define Impala_Core_Feature_WeightedFeatureList_h

#include "Util/StringParser.h"
#include "Util/IOBuffer.h"

namespace Impala
{
namespace Core
{
namespace Feature
{


class WeightedFeatureList
{
public:

    WeightedFeatureList()
    {
    }

    WeightedFeatureList(CString input)
    {
        ParseAndAdd(input);
    }

    void
    Clear()
    {
        mFeatures.clear();
        mWeights.clear();
    }

    int
    Size() const
    {
        return mFeatures.size();
    }

    String
    GetFeature(int i) const
    {
        return mFeatures[i];
    }

    Real64
    GetWeight(int i) const
    {
        return mWeights[i];
    }

    Real64
    GetTotalWeight() const
    {
        Real64 res = 0;
        for (int i=0 ; i<mWeights.size() ; i++)
            res += mWeights[i];
        return res;
    }

    void
    Add(CString feature, Real64 weight)
    {
        mFeatures.push_back(feature);
        mWeights.push_back(weight);
    }

    void
    ParseAndAdd(String input)
    {
        if (StringStartsWith(input, "inputFeatures"))
        {
            Util::StringParser p(input);
            String dummy = p.GetString(' ', true);
            input = p.GetString('"', true);
        }
        Util::StringParser p(input);
        while (!p.TheEnd())
        {
            double weight = p.GetDouble(' ', true);
            String feature = p.GetString(' ', false);
            if (feature.empty())
                break;
            mWeights.push_back(weight);
            mFeatures.push_back(feature);
        }
    }

    int
    Diff(const WeightedFeatureList* arg) const
    {
        if (Size() != arg->Size())
        {
            ILOG_ERROR("Size differs: " << Size() << " vs " << arg->Size());
            return 1;
        }
        int nDiff = 0;
        for (int i=0 ; i<Size() ; i++)
        {
            if (GetFeature(i) != arg->GetFeature(i))
            {
                ILOG_DEBUG("Feature " << i << " differs " << GetFeature(i)
                           << " vs " << arg->GetFeature(i));
                nDiff++;
            }
            if (fabs(GetWeight(i) - arg->GetWeight(i)) > 0.00001)
            {
                ILOG_DEBUG("Weight " << i << " differs " << GetWeight(i)
                           << " vs " << arg->GetWeight(i));
                nDiff++;
            }
        }
        if (nDiff > 0)
            ILOG_ERROR("Found " << nDiff << " differences in features/weights");
        return nDiff;
    }

private:

    std::vector<String> mFeatures;
    std::vector<Real64> mWeights;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(WeightedFeatureList, Impala.Core.Feature); 

void
Read(WeightedFeatureList* featList, Util::IOBuffer* buf)
{
    ILOG_VAR(Impala.Core.Feature.WeightedFeatureList.Read);
    if (! (buf && buf->Valid()))
    {
        ILOG_ERROR("Invalid IOBuffer");
        return;
    }

    std::vector<String> lines;
    buf->ReadStrings(std::back_inserter(lines), true, -1);
    for (int i=0 ; i<lines.size() ; i++)
        featList->ParseAndAdd(lines[i]);
}

bool
Read(WeightedFeatureList* featList, Persistency::File file)
{
    ILOG_VAR(Impala.Core.Feature.WeightedFeatureList.Read);
    Util::IOBuffer* buf = file.GetReadBuffer();
    if (buf)
    {
        Read(featList, buf);
        delete buf;
        return true;
    }
    return false;
}

bool
Write(WeightedFeatureList* featList, Util::IOBuffer* buf)
{
    ILOG_VAR(Impala.Core.Feature.WeightedFeatureList.Write);
    if (! (buf && buf->Valid()))
    {
        ILOG_ERROR("Invalid IOBuffer");
        return false;
    }

    for (int i=0 ; i<featList->Size() ; i++)
    {
        String s =
            MakeString(featList->GetWeight(i)) + " " + featList->GetFeature(i);
        buf->Puts(s);
    }
    return true;
}

bool
Write(WeightedFeatureList* featList, Persistency::File file)
{
    Util::IOBuffer* buf = file.GetWriteBuffer();
    if (buf)
    {
        Write(featList, buf);
        delete buf;
        return true;
    }
    return false;
}

} // namespace Feature
} // namespace Core
} // namespace Impala

#endif

---