rule.cpp

apriori算法是数据挖掘的经典算法,它基于关联规则的思想.此为我的第3个收藏

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "rule.h"
#include "util.h"



AssociationRule::AssociationRule()
{
    m_minConfidence = 0.90;
    m_numRules = 0;
    m_LargeItemSets = (ItemSets *) new ItemSets();
    m_Rules = (ARRuleSetNode *)NULL;
};

AssociationRule::~AssociationRule()
{
    ARRuleSetNode *rn, *temp;

    rn = m_Rules;
    while(rn != (ARRuleSetNode *)NULL)
    {
        temp = rn->next;
        if(rn->m_premise != NULL)
            delete rn->m_premise;

        if(rn->m_consequence != NULL)
            delete rn->m_consequence;

        delete rn;
        rn = temp;
    }

};



void AssociationRule::genrules()
{
    ItemSet *current;
    
    printf("\nGenerating Association Rules from Large Item Sets ...\n");
    printf("  Minimum Confidence is %lf.\n", m_minConfidence);
    
    for(int i = 0; i < m_LargeItemSets->count; i++)
    {
        current = m_LargeItemSets->itemsetof(i);
        if(current->count > 1)
            ruler(current, current);

        delete current;
    }
    
    printf("  %d rules have been generated!\n", m_numRules);

    return;
}

void AssociationRule::ruler(ItemSet *Lk, ItemSet *Am)
{
    ItemSet *current;
    ItemSet *Aminusone;
    int pos;
    double conf;
    long necConfidence;


    for(int i = 0; i < Am->count; i++)
    {
        current = Am->clone();
        current->remove(i);

        pos = m_LargeItemSets->indexof(current);
        if(pos >= 0)
        {
            Aminusone = m_LargeItemSets->itemsetof(pos);

            conf = ((double)(Lk->support))/(double)(Aminusone->support);
            necConfidence = (long)(m_minConfidence*(double)(Aminusone->support) + 0.5);

            if(necConfidence <= Lk->support)
            {
                add(Lk, Aminusone, conf);

                if(Aminusone->count > 1)
                    ruler(Lk, Aminusone);
            }

            delete Aminusone;
        }

        delete current;
    }

    return;
}


void AssociationRule::add(ItemSet *Lk, ItemSet *Aminusone, double confidence)
{
    ItemSet *rightitems;
    ARRuleSetNode *newRule;
    ARRuleSetNode *browser;
    int j;

    rightitems = Lk->substract(Aminusone);

    browser = m_Rules;
    while(browser != (ARRuleSetNode *)NULL)
    {
        if((browser->m_premise->diff(Aminusone) == TOTALEQUAL) && (browser->m_consequence->diff(rightitems) == TOTALEQUAL))
        {
            delete rightitems;
            return;
        }

        browser = browser->next;
    }

    newRule = (ARRuleSetNode *) new ARRuleSetNode();

    newRule->m_premise = Aminusone->clone();

    newRule->m_consequence = rightitems->clone();

    newRule->m_confidence = confidence;

    newRule->next = m_Rules;
    m_Rules = newRule;

    m_numRules++;

    return;
}


void AssociationRule::writeto(char *filename)
{
    ARRuleSetNode *currentRule;
    FILE *fp;

    fp = fopen(filename,"wt");

    currentRule = m_Rules;
    while(currentRule != (ARRuleSetNode *)NULL)
    {
        fprintf(fp, "(%lf) ", currentRule->m_confidence);
        for(int i = 0; i < currentRule->m_premise->count; i++)
            fprintf(fp, " %d", currentRule->m_premise->itemof(i));
        fprintf(fp, "(%d)", currentRule->m_premise->support);

        fprintf(fp, "   ->   ");

        for(int i = 0; i < currentRule->m_consequence->count; i++)
            fprintf(fp, " %d ", currentRule->m_consequence->itemof(i));

        fprintf(fp, "\n");

        currentRule = currentRule->next;
    }

    return;
}