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

---

RandomTree.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_RandomTree_h
#define Impala_Core_Feature_RandomTree_h

#include "Core/Vector/Types.h"
#include "Core/Feature/RandomTreeTable.h"

namespace Impala
{
namespace Core
{
namespace Feature
{

class RandomTree
{
public:
    //leaf constructor
    RandomTree(int codeword)
    {
        if(codeword < 0)
            ILOG_ERROR("illegal codeword in RandomTree node c'tor");
        mCodeWord = codeword;
        mSplitDimension = -1;
        mSplitValue = -1;
        mLeft = 0;
        mRight = 0;
        mCount = -1;
    }

    RandomTree(int codeword, int count)
    {
        if(codeword < 0)
            ILOG_ERROR("illegal codeword in RandomTree node c'tor");
        mCodeWord = codeword;
        mSplitDimension = -1;
        mSplitValue = -1;
        mLeft = 0;
        mRight = 0;
        mCount = count;
    }

    RandomTree(int splitDimension, double splitValue,
               RandomTree* left, RandomTree* right)
    {
        mCodeWord = -1;
        mSplitDimension = splitDimension;
        mSplitValue = splitValue;
        mLeft = left;
        mRight = right;
        mCount = -2;
    }

    ~RandomTree()
    {
        if(mCodeWord == -1)
        {
            delete mLeft;
            delete mRight;
        }
    }
    
    int
    GetCodeWord(const Vector::VectorReal64& v)
    {
        ILOG_DEBUG("GetCodeWord mCW="<<mCodeWord<<" mD="<<mSplitDimension<<
                   " mV="<<mSplitValue);
        if(mCodeWord >= 0) //if this is a leaf
            return mCodeWord;
        ILOG_DEBUG("left="<<(int*)mLeft<<" right="<<(int*)mRight);
        if(v[mSplitDimension] < mSplitValue)
            return mLeft->GetCodeWord(v);
        return mRight->GetCodeWord(v);
    }

    void
    GetSplit(int& dimension, double& value)
    {
        dimension = mSplitDimension;
        value = mSplitValue;
    }

    void
    Dump(std::ostream& os, int nrNodes)
    {
        Dump(os, 0, nrNodes);
    }

    void
    DumpCount(std::ostream& os)
    {
        if(mCodeWord >= 0)
            os << mCodeWord <<": "<< mCount << "\n";
        else
        {
            mLeft->DumpCount(os);
            mRight->DumpCount(os);
        }
    }

    bool
    operator ==(const RandomTree& that)
    {
        if(mCodeWord != that.mCodeWord)
            return false;
        if(mCodeWord >= 0)
            return true;
        return mSplitValue == that.mSplitValue &&
               mSplitDimension == that.mSplitDimension &&
               *mLeft == *(that.mLeft) &&
               *mRight == *(that.mRight);
    }

    bool
    operator !=(const RandomTree& that)
    {
        return ! operator ==(that);
    }

    
private:
    void
    Dump(std::ostream& os, int level, int& nrNodes)
    {
        if(nrNodes == 0)
            return;
        --nrNodes;
        for(int i=0 ; i<level ; ++i)
            os << "  ";
        if(mCodeWord >= 0)
            os <<"w:"<< mCodeWord << std::endl;
        else
        {
            os <<"d:"<< mSplitDimension <<" v:"<< mSplitValue << std::endl;
            mLeft->Dump(os, level+1, nrNodes);
            mRight->Dump(os, level+1, nrNodes);
        }
    }

    // >0 if this is a leaf, otherwise 0
    int mCodeWord;
    int mCount; // only for debugging of construction
    // next members only used if not a leaf
    int mSplitDimension;
    double mSplitValue;
    RandomTree* mLeft;
    RandomTree* mRight;
    friend void Write(RandomTree*, RandomTreeTable*);
    ILOG_VAR_DECL;
};
ILOG_VAR_INIT(RandomTree, Impala.Core.Feature);


void
Write(RandomTree* tree, RandomTreeTable* table)
{
    table->Add(tree->mCodeWord, tree->mSplitDimension, tree->mSplitValue);
    if(tree->mCodeWord == -1)
    {
        Write(tree->mLeft, table);
        Write(tree->mRight, table);
    }
}
    
RandomTree*
Read(RandomTreeTable* table, int& index)
{
    ILOG_VAR(Impala.Core.Feature.RandomTree.Read);
    if(index > table->Size())
        ILOG_ERROR("parse error in Read(RandomTreeTable*,int)");
    int word = table->Get1(index);
    int dimension = table->Get2(index);
    double value = table->Get3(index);
    ++index;
    if(word>=0)
        return new RandomTree(word);
    else
    {
        RandomTree* l = Read(table, index);
        RandomTree* r = Read(table, index);
        return new RandomTree(dimension, value, l, r);
    }
}

} // namespace
} // namespace
} // namespace

#endif

---