hooks.c

这是数据挖掘算法的cubist算法的具体实现.运行在dos下.

			XStack[XSN++].sval =
			    ( Unknown(Case, Att) && ! NotApplic(Case, Att) ? 0 :
			      AttValName[Att][XDVal(Case, Att)] );
		    }
		    break;

	    case OP_NUM:
		    XStack[XSN++].cval = DefNVal(DElt);
		    break;

	    case OP_STR:
		    XStack[XSN++].sval = DefSVal(DElt);
		    break;

	    case OP_AND:
		    bv1 = XStack[XSN-2].dval;
		    bv2 = XStack[XSN-1].dval;
		    XStack[XSN-2].dval = ( bv1 == 3 || bv2 == 3 ? 3 :
					   D2(bv1 == 2 && bv2 == 2 ? 2 : 3) );
		    XSN--;
		    break;

	    case OP_OR:
		    bv1 = XStack[XSN-2].dval;
		    bv2 = XStack[XSN-1].dval;
		    XStack[XSN-2].dval = ( bv1 == 2 || bv2 == 2 ? 2 :
					   D2(bv1 == 2 || bv2 == 2 ? 2 : 3) );
		    XSN--;
		    break;

	    case OP_EQ:
		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    XStack[XSN-2].dval = ( cv1 == cv2 ? 2 : 3 );
		    XSN--;
		    break;

	    case OP_NE:
		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    XStack[XSN-2].dval = ( cv1 != cv2 ? 2 : 3 );
		    XSN--;
		    break;

	    case OP_GT:
		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    XStack[XSN-2].dval = CD2(cv1 > cv2 ? 2 : 3);
		    XSN--;
		    break;

	    case OP_GE:
		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    XStack[XSN-2].dval = CD2(cv1 >= cv2 ? 2 : 3);
		    XSN--;
		    break;

	    case OP_LT:
		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    XStack[XSN-2].dval = CD2(cv1 < cv2 ? 2 : 3);
		    XSN--;
		    break;

	    case OP_LE:
		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    XStack[XSN-2].dval = CD2(cv1 <= cv2 ? 2 : 3);
		    XSN--;
		    break;

	    case OP_SEQ:
		    sv1 = XStack[XSN-2].sval;
		    sv2 = XStack[XSN-1].sval;
		    XStack[XSN-2].dval =
			( ! sv1 && ! sv2 ? 2 :
			  ! sv1 || ! sv2 ? 3 :
			  ! strcmp(sv1, sv2) ? 2 : 3 );
		    XSN--;
		    break;

	    case OP_SNE:
		    sv1 = XStack[XSN-2].sval;
		    sv2 = XStack[XSN-1].sval;
		    XStack[XSN-2].dval =
			( ! sv1 && ! sv2 ? 3 :
			  ! sv1 || ! sv2 ? 2 :
			  strcmp(sv1, sv2) ? 2 : 3 );
		    XSN--;
		    break;

	    case OP_PLUS:
		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    XStack[XSN-2].cval = C2(cv1 + cv2);
		    XSN--;
		    break;

	    case OP_MINUS:
		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    XStack[XSN-2].cval = C2(cv1 - cv2);
		    XSN--;
		    break;

	    case OP_MULT:
		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    XStack[XSN-2].cval = C2(cv1 * cv2);
		    XSN--;
		    break;

	    case OP_DIV:
		    /*  Note: have to set precision of result  */

		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    if ( ! cv2 ||
			 CUnknownVal(XStack[XSN-2]) ||
			 CUnknownVal(XStack[XSN-1]) ||
			 NotApplicVal(XStack[XSN-2]) ||
			 NotApplicVal(XStack[XSN-1]) )
		    {
			XStack[XSN-2].cval = _UNK.cval;
		    }
		    else
		    {
			Mult = Denominator(cv1);
			cv1 = cv1 / cv2;
			while ( fabs(cv2) > 1 )
			{
			    Mult *= 10;
			    cv2 /= 10;
			}
			XStack[XSN-2].cval = rint(cv1 * Mult) / Mult;
		    }
		    XSN--;
		    break;

	    case OP_MOD:
		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    XStack[XSN-2].cval = C2(fmod(cv1, cv2));
		    XSN--;
		    break;

	    case OP_POW:
		    cv1 = XStack[XSN-2].cval;
		    cv2 = XStack[XSN-1].cval;
		    XStack[XSN-2].cval =
			( CUNA(XSN-1) || CUNA(XSN-2) ||
			  ( cv1 < 0 && ceil(cv2) != cv2 ) ? _UNK.cval :
			  pow(cv1, cv2) );
		    XSN--;
		    break;

	    case OP_UMINUS:
		    cv1 = XStack[XSN-1].cval;
		    XStack[XSN-1].cval = C1(-cv1);
		    break;

	    case OP_SIN:
		    cv1 = XStack[XSN-1].cval;
		    XStack[XSN-1].cval = C1(sin(cv1));
		    break;

	    case OP_COS:
		    cv1 = XStack[XSN-1].cval;
		    XStack[XSN-1].cval = C1(cos(cv1));
		    break;

	    case OP_TAN:
		    cv1 = XStack[XSN-1].cval;
		    XStack[XSN-1].cval = C1(tan(cv1));
		    break;

	    case OP_LOG:
		    cv1 = XStack[XSN-1].cval;
		    XStack[XSN-1].cval =
			( CUNA(XSN-1) || cv1 <= 0 ? _UNK.cval : log(cv1) );
		    break;

	    case OP_EXP:
		    cv1 = XStack[XSN-1].cval;
		    XStack[XSN-1].cval = C1(exp(cv1));
		    break;

	    case OP_INT:
		    cv1 = XStack[XSN-1].cval;
		    XStack[XSN-1].cval = C1(rint(cv1));
		    break;

	    case OP_END:
		    ReturnVal.dval = XStack[0].dval;
		    return ReturnVal;
	}
    }
}



/*************************************************************************/
/*									 */
/*	Locate value Val in List[First] to List[Last]			 */
/*									 */
/*************************************************************************/


int Which(String Val, String *List, int First, int Last)
/*  -----  */
{
    int	n=First;

    while ( n <= Last && strcmp(Val, List[n]) ) n++;

    return ( n <= Last ? n : First-1 );
}



/*************************************************************************/
/*									 */
/*	Free global names data						 */
/*									 */
/*************************************************************************/


void FreeNamesData()
/*   -------------  */
{
    Attribute a, t;

    FreeVector((void **) AttName, 1, MaxAtt);		AttName = Nil;

    ForEach(a, 1, MaxAtt)
    {
	if ( a != ClassAtt && Discrete(a) )
	{
	    FreeVector((void **) AttValName[a], 1, MaxAttVal[a]);
	}
    }
    FreeUnlessNil(AttValName);				AttValName = Nil;

    /*  Definitions (if any)  */

    if ( AttDef )
    {
	ForEach(a, 1, MaxAtt)
	{
	    if ( AttDef[a] )
	    {
		for ( t = 0 ; DefOp(AttDef[a][t]) != OP_END ; t++ )
		{
		    if ( DefOp(AttDef[a][t]) == OP_STR )
		    {
			Free(DefSVal(AttDef[a][t]));
		    }
		}

		Free(AttDef[a]);
	    }
	}
	Free(AttDef);					AttDef = Nil;
    }

    FreeUnlessNil(MaxAttVal);				MaxAttVal = Nil;
    FreeUnlessNil(SpecialStatus);			SpecialStatus = Nil;

    FreeUnlessNil(AttMean);				AttMean = Nil;
    FreeUnlessNil(AttSD);				AttSD = Nil;
    FreeUnlessNil(AttPrec);				AttPrec = Nil;
    FreeUnlessNil(Modal);				Modal = Nil;
}



/*************************************************************************/
/*									 */
/*	Read next char keeping track of line numbers			 */
/*									 */
/*************************************************************************/


int InChar(FILE *f)
/*  ------  */
{
    if ( ! *LBp )
    {
	LBp = LineBuffer;

	if ( ! fgets(LineBuffer, MAXLINEBUFFER, f) )
	{
	    LineBuffer[0] = '\00';
	    return EOF;
	}

	LineNo++;
    }
	
    return (int) *LBp++;
}



/*=======================================================================*/
/*									 */
/*	Get case descriptions from data file				 */
/*									 */
/*=======================================================================*/


#define Inc 2048

ItemCount	*Freq;			/* discrete value frequencies */


/*************************************************************************/
/*									 */
/*  Read raw case descriptions from file with given extension.		 */
/*									 */
/*  On completion, cases are stored in array Item in the form		 */
/*  of Descriptions (i.e. arrays of attribute values), and		 */
/*  MaxItem is set to the highest numbered case.			 */
/*									 */
/*************************************************************************/


#if defined WIN32 || defined _CONSOLE
#define AltRandom ((rand() & 32767) / 32768.0)
#else
#define AltRandom drand48()
double drand48();
#endif

#define XError(a,b,c)	Error(a,b,c)


void GetData(FILE *Df, Boolean Train, Boolean AllowUnknownTarget)
/*   -------  */
{
    ItemNo	ItemSpace, i;
    Description	DVec;
    Boolean	AnyUnknown=false, FirstIgnore=true, *AttMsg;
    Attribute	Att;
    ContValue	Val, Range;
    char	CVS[20];

    LineNo = 0;

    if ( Train || ! Item )
    {
	MaxItem = MaxLabel = ItemSpace = 0;
	Item = Alloc(1, Description);	/* for error reporting */
    }
    else
    {
	ItemSpace = MaxItem + 1;
	MaxItem++;
    }


    while ( (DVec = GetDescription(Df, Train)) )
    {

	/*  Make sure there is room for another item  */

	if ( MaxItem >= ItemSpace )
	{
	    ItemSpace += Inc;
	    Realloc(Item, ItemSpace+1, Description);
	}

	/*  Ignore cases with N/A target value (!) but possibly allow
	    cases with unknown target value  */

	if ( ! NotApplic(DVec, ClassAtt) &&
	     ( AllowUnknownTarget || CVal(DVec, ClassAtt) != UNKNOWN ) )
	{
	    Item[MaxItem] = DVec;

#ifndef _CONSOLE
#ifdef WIN32
	    if ( TerminateSignal() )
	    {
		fclose(Df);
		NotifyNumber("", -1);
		Goodbye(0);
	    }

	    if ( MaxItem > 0 && MaxItem % 100 == 0 )
	    {
		NotifyNumber("Case", MaxItem);
	    }
#endif
#endif
	    MaxItem++;
	}
	else
	{
	    if ( FirstIgnore && Of )
	    {
		fprintf(Of, ( AllowUnknownTarget ? T_IgnoreNATarget :
						   T_IgnoreBadTarget ));
		FirstIgnore = false;
	    }

	    FreeCase(DVec);
	}
    }

    fclose(Df);
    MaxItem--;

    if ( Of && MaxItem < 0 )
    {
	fprintf(Of, T_NoCases);
	Goodbye(1);
    }

#ifndef _CONSOLE
#ifdef WIN32
    NotifyNumber("", -1);
#endif
#endif

    /*  Replace unknown values by means or modals  */


    AttMsg = AllocZero(MaxAtt+1, Boolean);

    ForEach(i, 0, MaxItem)
    {
	AnyUnknown |= ReplaceUnknowns(Item[i], AttMsg);
    }

    if ( Of && AnyUnknown )
    {
	fprintf(Of, T_ReplaceUnknowns);

	ForEach(Att, 1, MaxAtt)
	{
	    if ( AttMsg[Att] )
	    {
		if ( Skip(Att) )
		{
		    fprintf(Of, "\t`%s' -- " T_NoAppVals "\n", AttName[Att]);
		    continue;
		}

		fprintf(Of, "\t`%s' " T_By " ", AttName[Att]);

		if ( Discrete(Att) )
		{
		    fprintf(Of, "`%s'\n", AttValName[Att][Modal[Att]]);
		}
		else
		{
		    CValToStr(AttMean[Att], Att, CVS);
		    fprintf(Of, "%s\n", CVS);
		}
	    }
	}
    }

    if ( Train )
    {
	/*  Generate global max and min values  */

	Ceiling = -1E38;
	Floor   =  1E38;

	ForEach(i, 0, MaxItem)
	{
	    if ( (Val = Class(Item[i]) ) > Ceiling ) Ceiling = Val;
	    if ( Val < Floor ) Floor = Val;
	}

	Range = Ceiling - Floor;
	Ceiling += EXTRAP * Range;
	Floor   -= EXTRAP * Range;
    }

    Free(AttMsg);					AttMsg = Nil;
}



/*************************************************************************/
/*									 */
/*	Replace any unknown values in a case				 */
/*									 */
/*************************************************************************/


Boolean ReplaceUnknowns(Description Case, Boolean *AttMsg)
/*      ---------------  */
{
    Attribute	Att;
    Boolean	Replaced=false;

    ForEach(Att, 1, MaxAtt)
    {
	if ( Skip(Att) || Att == ClassAtt ) continue;

	if ( Discrete(Att) && ! DVal(Case, Att) )
	{
	    DVal(Case, Att) = Modal[Att];
	    if ( AttMsg ) AttMsg[Att] = Replaced = true;
	}
	else
	if ( Continuous(Att) && CVal(Case, Att) == UNKNOWN )
	{
	    CVal(Case, Att) = AttMean[Att];
	    if ( AttMsg ) AttMsg[Att] = Replaced = true;
	}
    }

    Class(Case) = CVal(Case, ClassAtt);

    return Replaced;
}



/*************************************************************************/
/*									 */
/*  Read a raw case description from file Df.				 */
/*									 */
/*  For each attribute, read the attribute value from the file.		 */
/*  If it is a discrete valued attribute, find the associated no.	 */
/*  of this attribute value (if the value is unknown this is 0).	 */
/*									 */
/*  Returns the Description of the case (i.e. the array of		 */
/*  attribute values).							 */
/*									 */
/*************************************************************************/


Description GetDescription(FILE *Df, Boolean Train)
/*          --------------  */
{
    Attribute	Att;
    char	Name[1000], *EndVal;
    int		Dv;
    ContValue	Cv;
    Description	DVec;
    Boolean	FirstValue=true;
#if defined WIN32  && ! defined _CONSOLE 
    extern int	XREF;
#endif


    if ( ReadName(Df, Name, 1000, '\00') )
    {
	DVec = AllocZero(MaxAtt+2, AttValue);
	ForEach(Att, 1, MaxAtt)
	{
	    if ( AttDef[Att] )
	    {
		DVec[Att] = EvaluateDef(AttDef[Att], DVec);
		if ( Continuous(Att) )
		{
		    CheckValue(DVec, Att);
		}
		continue;
	    }

	    /*  Get the attribute value if don't already have it  */

	    if ( ! FirstValue && ! ReadName(Df, Name, 1000, '\00') )
	    {
		XError(EOFINATT, AttName[Att], "");
		FreeCase(DVec);
		return Nil;
	    }
	    FirstValue = false;

	    if ( Exclude(Att) )
	    {
#if defined WIN32 && ! defined _CONSOLE
		if ( XREF || Att == LabelAtt )
#else
		if ( Att == LabelAtt )
#endif
		{
		    /*  Record the value as a string  */

		    SVal(DVec,Att) = StoreIVal(Name);
		}
	    }
	    else
	    if ( ! strcmp(Name, "?") )
	    {
		/*  Unknown value  */

		if ( Continuous(Att) )
		{
		    CVal(DVec, Att) = UNKNOWN;
		}
		else
		{
		    DVal(DVec, Att) = 0;
		}
	    }
	    else
	    if ( ! strcmp(Name, "N/A") )
	    {
		/*  Non-applicable value  */

		DVal(DVec, Att) = NA;
	    }
	    else
	    if ( Discrete(Att) )
	    {
		Dv = Which(Name, AttValName[Att], 1, MaxAttVal[Att]);
		if ( ! Dv )
		{
		    if ( StatBit(Att, DISCRETE) )
		    {
			if ( Train )
			{
			    /*  Add value to list  */

			    if ( MaxAttVal[Att] >= (long) AttValName[Att][0] )
			    {
				XError(TOOMANYVALS, AttName[Att],
					 (char *) AttValName[Att][0] - 1);
				Dv = MaxAttVal[Att];
			    }
			    else
			    {
				Dv = ++MaxAttVal[Att];
				AttValName[Att][Dv]   = strdup(Name);
				AttValName[Att][Dv+1] = "<other>"; /* no free */
			    }
			}
			else
			{
			    /*  Set value to "<other>"  */

			    Dv = MaxAttVal[Att] + 1;
			}
		    }
		    else
		    {
			XError(BADATTVAL, AttName[Att], Name);
		    }
		}
		DVal(DVec, Att) = Dv;
	    }
	    else
	    {
		/*  Continuous value  */

		if ( TStampVal(Att) )
		{
		    Cv = TStampToMins(Name);
		    if ( Cv >= 1E9 )	/* long time in future */
		    {
			XError(BADTSTMP, AttName[Att], Name);
			Cv = UNKNOWN;