see5-installer 0.1.0

data/ext/c5.0/text.i

@@ -0,0 +1,223 @@
+/*************************************************************************/
+/*									 */
+/*  Copyright 2010 Rulequest Research Pty Ltd.				 */
+/*									 */
+/*  This file is part of C5.0 GPL Edition, a single-threaded version	 */
+/*  of C5.0 release 2.07.						 */
+/*									 */
+/*  C5.0 GPL Edition is free software: you can redistribute it and/or	 */
+/*  modify it under the terms of the GNU General Public License as	 */
+/*  published by the Free Software Foundation, either version 3 of the	 */
+/*  License, or (at your option) any later version.			 */
+/*									 */
+/*  C5.0 GPL Edition is distributed in the hope that it will be useful,	 */
+/*  but WITHOUT ANY WARRANTY; without even the implied warranty of	 */
+/*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU	 */
+/*  General Public License for more details.				 */
+/*									 */
+/*  You should have received a copy of the GNU General Public License	 */
+/*  (gpl.txt) along with C5.0 GPL Edition.  If not, see 		 */
+/*									 */
+/*      <http://www.gnu.org/licenses/>.					 */
+/*									 */
+/*************************************************************************/
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Text strings for UTF-8 internationalization			 */
+/*	-------------------------------------------			 */
+/*									 */
+/*************************************************************************/
+
+
+
+	/*  General stuff  */
+
+//#define UTF8		 	/* uncomment if using UTF-8 */
+
+#ifdef UTF8
+#define	 CharWidth(S)		UTF8CharWidth(S)
+#else
+#define	 CharWidth(S)		(int) strlen(S)
+#endif
+
+
+	/*  Strings with width/format restrictions  */
+	/*  (W = width when printed, C = centered)  */
+
+#define	 F_Fold			"Fold"				/* W<8 */
+#define	 F_UFold		"----"				/* W same */
+#define	 F_Trial		"Trial"				/* W<8 */
+#define	 F_UTrial		"-----"				/* W same */
+#define	 F_DecisionTree16	"  Decision Tree "		/* W=16C */
+#define	 F_SizeErrors		"Size      Errors"		/* W=16 */
+#define	 F_DecisionTree23	"     Decision Tree     "	/* W=23C */
+#define	 F_SizeErrorsCost	"Size      Errors   Cost"	/* W=23 */
+#define	 F_Rules16		"      Rules     "		/* W=16C */
+#define	 F_NoErrors		"  No      Errors"		/* W=16 */
+#define	 F_Rules23		"         Rules         "	/* W=23C */
+#define	 F_NoErrorsCost		"  No      Errors   Cost"	/* W=23 */
+#define	 F_Rules		"Rules"				/* W<8 */
+#define	 F_URules		"-----"				/* W same */
+#define	 F_Errors		"Errors"			/* W<8 */
+#define	 F_UErrors		"------"			/* W same */
+#define	 F_Cost			"Cost"				/* W<8 */
+#define	 F_UCost		"----"				/* W same */
+#define	 F_Boost		"boost"				/* W<8 */
+
+
+	/*  Strings of arbitrary length  */
+
+#define	 T_See5			"See5"
+#define	 T_C50			"C5.0"
+#define	 TX_Release(n)		"Release " n
+
+#define	 T_OptHeader		"\n    Options:\n"
+#define	 T_OptApplication	"\tApplication `%s'\n"
+#define	 T_OptBoost		"\tBoosted classifiers\n"
+#define	 T_OptProbThresh	"\tProbability thresholds\n"
+#define	 T_OptTrials		"\t%d boosting trials\n"
+#define	 T_OptSubsets		"\tTests on discrete attribute groups\n"
+#define	 T_OptMinCases		"\tTests require 2 branches with >=%g cases\n"
+#define	 T_OptCF		"\tPruning confidence level %g%%\n"
+#define	 T_OptRules		"\tRule-based classifiers\n"
+#define	 T_OptSampling		"\tUse %g%% of data for training\n"
+#define	 T_OptSeed		"\tRandom seed %d\n"
+#define	 T_OptUtility		"\tRule utility ordering (1/%d's)\n"
+#define	 T_OptNoCosts		"\tFocus on errors (ignore costs file)\n"
+#define	 T_OptWinnow		"\tWinnow attributes\n"
+#define	 T_OptNoGlobal		"\tDo not use global tree pruning\n"
+#define	 T_OptXval		"\tCross-validate using %d folds\n"
+#define	 T_UnregnizedOpt	"\n    **  Unrecognised option %s %s\n"
+#define	 T_SummaryOpts		"    **  Summary of options for c5.0:\n"
+#define	 T_ListOpts		"\t-f <filestem>\tapplication filestem\n"\
+				"\t-r\t\tuse rule-based classifiers\n"\
+				"\t-u <bands>\torder rules by utility in"\
+					" bands\n"\
+				"\t-w\t\tinvoke attribute winnowing\n"\
+				"\t-b\t\tinvoke boosting\n"\
+				"\t-t <trials>\tnumber of boosting trials\n"\
+				"\t-p\t\tuse soft thresholds\n"\
+				"\t-e\t\tfocus on errors (ignore costs file)\n"\
+				"\t-s\t\tfind subset tests for discrete atts\n"\
+				"\t-g\t\tdo not use global tree pruning\n"\
+				"\t-m <cases>\trestrict allowable splits\n"\
+				"\t-c <percent>\tconfidence level (CF) for"\
+					" pruning\n"\
+				"\t-S <percent>\ttraining sample percentage\n"\
+				"\t-X <folds>\tcross-validate\n"\
+				"\t-I <integer>\trandom seed for sampling"\
+					" and cross-validation\n"\
+				"\t-h\t\tprint this message\n"
+#define	 T_UBWarn		"    **  Warning (-u): rule ordering "\
+					"has no effect on boosting\n"
+#define	 T_ClassVar		"\nClass specified by attribute `%s'\n"
+#define	 TX_ReadData(c,a,f)	"\nRead %d cases (%d attributes) from"\
+					" %s.data\n", c, a, f
+#define	 TX_ReadTest(c,f)	"Read %d cases from %s.test\n", c, f
+#define	 T_ReadCosts		"Read misclassification costs from %s.costs\n"
+#define	 T_CWtAtt		"Using relative case weighting\n"
+#define	 T_AttributesIn		"\nAttributes included:\n"
+#define	 T_AttributesOut	"\nAttributes excluded:\n"
+#define	 T_AttributesWinnowed	"\n%d attribute%s winnowed\n"
+#define	 T_EstImportance	"Estimated importance of remaining"\
+					" attributes:\n\n"
+#define	 T_NoWinnow		"\nNo attributes winnowed\n"
+#define	 T_EvalTrain		"\n\nEvaluation on training data (%d cases):\n"
+#define	 T_Usage		"\n\n\tAttribute usage:\n\n"
+#define	 T_EvalTest		"\nEvaluation on test data (%d cases):\n"
+#define	 T_Time			"\n\nTime: %.1f secs\n"
+
+#define	 T_IgnoreBadClass	"*** ignoring cases with bad or unknown class\n"
+
+#define	 T_Subtree		"\nSubTree [S%d]\n"
+#define	 T_ElementOf		"in"
+#define	 T_InRange		"in"
+#define	 T_RuleHeader		"\nRule "
+#define	 T_RuleLift		", lift %.1f)\n"
+#define	 T_IsUnknown		" is unknown\n"
+
+#define	 TX_Reduced1(t)		( (t) > 1 ?\
+				   "\n*** boosting reduced to %d trials since"\
+					" last classifier is very accurate\n" :\
+				   "\n*** boosting reduced to %d trial since"\
+					" last classifier is very accurate\n" )
+#define	 TX_Reduced2(t)		( (t) > 1 ?\
+				   "\n*** boosting reduced to %d trials since"\
+					" last classifier is very inaccurate\n" :\
+				   "\n*** boosting reduced to %d trial since"\
+					" last classifier is very inaccurate\n" )
+#define	 T_Abandoned		"\n*** boosting abandoned (too few classifiers)\n"
+#define	 T_BoostingUnhelpful	"\n*** warning: boosting may be unhelpful\n"
+#define	 T_Composite		"Composite ruleset:"
+#define	 T_Tree			"Decision tree:"
+#define	 T_Rules		"Rules:"
+
+#define	 T_Default_class	"Default class"
+#define	 T_boost		"boost"
+#define	 T_composite_ruleset	"composite ruleset"
+#define	 T_Rule_utility_summary	"Rule utility summary"
+#define	 T_class		"class"
+#define	 T_classified_as	"classified as"
+#define	 T_Summary		"Summary"
+#define	 T_FoldsReduced		"\n*** folds reduced to number of cases\n"
+#define	 T_EvalHoldOut		"\nEvaluation on hold-out data (%d cases):\n"
+#define	 T_Summary		"Summary"
+#define	 T_Fold			"Fold"
+#define	 T_Mean			"Mean"
+#define	 T_SE			"SE"
+
+#define	 TX_Line(l,f)		"*** line %d of `%s': ", l, f
+#define	 E_NOFILE(f,e)		"cannot open file %s%s\n", f, e
+#define	 E_ForWrite		" for writing"
+#define	 E_BADCLASSTHRESH	"bad class threshold `%s'\n"
+#define	 E_LEQCLASSTHRESH	"class threshold `%s' <= previous threshold\n"
+#define	 E_BADATTNAME		"`:' or `:=' expected after attribute name"\
+					" `%s'\n"
+#define	 E_EOFINATT		"unexpected eof while reading attribute `%s'\n"
+#define	 E_SINGLEATTVAL(a,v)	"attribute `%s' has only one value `%s'\n",\
+					a, v
+#define	 E_DUPATTNAME		"multiple attributes with name `%s'\n"
+#define	 E_CWTATTERR		"case weight attribute must be continuous\n"
+#define	 E_BADATTVAL(v,a)	"bad value of `%s' for attribute `%s'\n", v, a
+#define	 E_BADNUMBER(a)		"value of `%s' changed to `?'\n", a
+#define	 E_BADCLASS		"bad class value `%s'\n"
+#define	 E_BADCOSTCLASS		"bad class `%s'\n"
+#define	 E_BADCOST		"bad cost value `%s'\n"
+#define	 E_NOMEM		"unable to allocate sufficient memory\n"
+#define	 E_TOOMANYVALS(a,n)	"too many values for attribute `%s'"\
+					" (max %d)\n", a, n
+#define	 E_BADDISCRETE		"bad number of discrete values for attribute"\
+					" `%s'\n"
+#define	 E_NOTARGET		"target attribute `%s' not found or"\
+					" type `ignore'\n"
+#define	 E_BADCTARGET		"target attribute `%s' must be"\
+					" type `continuous'\n"
+#define	 E_BADDTARGET		"target attribute `%s' must be specified by"\
+					" a list of discrete values\n"
+#define	 E_LONGNAME		"overlength name: check data file formats\n"
+#define	 E_HITEOF		"unexpected end of file\n"
+#define	 E_MISSNAME		"missing name or value before `%s'\n"
+#define	 E_BADTSTMP(d,a)	"bad timestamp `%s' for attribute `%s'\n", d, a
+#define	 E_BADDATE(d,a)		"bad date `%s' for attribute `%s'\n", d, a
+#define	 E_BADTIME(d,a)		"bad time `%s' for attribute `%s'\n", d, a
+#define	 E_UNKNOWNATT		"unknown attribute name `%s'\n"
+#define	 E_BADDEF1(a,s,x)	"in definition of attribute `%s':\n"\
+					"\tat `%.12s': expect %s\n", a, s, x
+#define	 E_BADDEF2(a,s,x)	"in definition of attribute `%s':\n"\
+					"\t`%s': %s\n", a, s, x
+#define	 E_SAMEATT(a,b)		"[warning] attribute `%s' is identical to"\
+					" attribute `%s'\n", a, b
+#define	 E_BADDEF3		"cannot define target attribute `%s'\n"
+#define	 E_BADDEF4		"[warning] target attribute appears in"\
+					" definition of attribute `%s'\n"
+#define	 EX_MODELFILE(f)	"file %s incompatible with .names file\n", f
+#define	 E_MFATT		"undefined or excluded attribute"
+#define	 E_MFATTVAL		"undefined attribute value"
+#define	 E_MFCLASS		"undefined class"
+#define	 E_MFEOF		"unexpected eof"
+#define	 T_ErrorLimit		"\nError limit exceeded\n"
+#define	 TX_IllegalValue(v,l,h)	"\t** illegal value %g -- "\
+				"should be between %g and %g\n", v, l, h

data/ext/c5.0/trees.c

@@ -0,0 +1,740 @@
+/*************************************************************************/
+/*									 */
+/*  Copyright 2010 Rulequest Research Pty Ltd.				 */
+/*									 */
+/*  This file is part of C5.0 GPL Edition, a single-threaded version	 */
+/*  of C5.0 release 2.07.						 */
+/*									 */
+/*  C5.0 GPL Edition is free software: you can redistribute it and/or	 */
+/*  modify it under the terms of the GNU General Public License as	 */
+/*  published by the Free Software Foundation, either version 3 of the	 */
+/*  License, or (at your option) any later version.			 */
+/*									 */
+/*  C5.0 GPL Edition is distributed in the hope that it will be useful,	 */
+/*  but WITHOUT ANY WARRANTY; without even the implied warranty of	 */
+/*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU	 */
+/*  General Public License for more details.				 */
+/*									 */
+/*  You should have received a copy of the GNU General Public License	 */
+/*  (gpl.txt) along with C5.0 GPL Edition.  If not, see 		 */
+/*									 */
+/*      <http://www.gnu.org/licenses/>.					 */
+/*									 */
+/*************************************************************************/
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Routines for displaying, building, saving and restoring trees	 */
+/*	-------------------------------------------------------------	 */
+/*									 */
+/*************************************************************************/
+
+
+#include "defns.i"
+#include "extern.i"
+
+
+#define	TabSize		4
+#define Utility		ClassDist[0]
+#define Digits(n)	((n) < 10 ? 3 : (int)(3 + log(n-1) / log(10.0)))
+
+
+	/*  If lines look like getting too long while a tree is being
+	    printed, subtrees are broken off and printed separately after
+	    the main tree is finished	 */
+
+int	SubTree,		/* highest subtree to be printed */
+	SubSpace=0;		/* maximum subtree encountered */
+Tree	*SubDef=Nil;		/* pointers to subtrees */
+Boolean	LastBranch[Width];	/* whether printing last branch of subtree */
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Calculate the depth of nodes in a tree in Utility field		 */
+/*									 */
+/*************************************************************************/
+
+
+void FindDepth(Tree T)
+/*   ---------  */
+{
+    float	MaxDepth=0;
+    DiscrValue	v;
+
+    if ( T->NodeType )
+    {
+	ForEach(v, 1, T->Forks)
+	{
+	    FindDepth(T->Branch[v]);
+	    if ( T->Branch[v]->Utility > MaxDepth )
+	    {
+		MaxDepth = T->Branch[v]->Utility;
+	    }
+	}
+    }
+
+    T->Utility = MaxDepth + 1;
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Display entire decision tree T					 */
+/*									 */
+/*************************************************************************/
+
+
+void PrintTree(Tree T, String Title)
+/*   ---------  */
+{
+    int s;
+
+    FindDepth(T);
+
+    SubTree=0;
+    fprintf(Of, "\n%s\n", Title);
+    Show(T, 0);
+    fprintf(Of, "\n");
+
+    ForEach(s, 1, SubTree)
+    {
+	fprintf(Of, T_Subtree, s);
+	Show(SubDef[s], 0);
+	fprintf(Of, "\n");
+    }
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Display the tree T with offset Sh				 */
+/*									 */
+/*************************************************************************/
+
+
+void Show(Tree T, int Sh)
+/*   ---- */
+{
+    DiscrValue	v, MaxV, BrNo, Simplest, First;
+    CaseCount	Errors=0.0;
+
+    if ( T->NodeType )
+    {
+	/*  See whether separate subtree needed  */
+
+	if ( Sh && Sh * TabSize + MaxLine(T) > Width )
+	{
+	    if ( ++SubTree >= SubSpace )
+	    {
+		SubSpace += 100;
+		if ( SubDef )
+		{
+		    Realloc(SubDef, SubSpace, Tree);
+		}
+		else
+		{
+		    SubDef = Alloc(SubSpace, Tree);
+		}
+	    }
+
+	    SubDef[SubTree] = T;
+	    fprintf(Of, " [S%d]", SubTree);
+	}
+	else
+	{
+	    MaxV = T->Forks;
+
+	    /*  Skip N/A branch if no cases  */
+
+	    First = ( EmptyNA(T) ? 2 : 1 );
+	    BrNo = First - 1;
+
+	    /*  Print simplest branches first  */
+
+	    while ( BrNo < MaxV )
+	    {
+		Simplest = First;
+		ForEach(v, 2, MaxV)
+		{
+		    if ( T->Branch[v]->Utility < T->Branch[Simplest]->Utility ||
+
+			 T->Branch[v]->Utility == 1 && ! T->Branch[v]->Cases )
+		    {
+			Simplest = v;
+		    }
+		}
+
+		LastBranch[Sh+1] = ( ++BrNo == MaxV );
+		ShowBranch(Sh, T, Simplest, (int)( BrNo == First ));
+		T->Branch[Simplest]->Utility = 1E10;
+	    }
+	}
+    }
+    else
+    {
+	fprintf(Of, " %s (%.8g", ClassName[T->Leaf], P1(T->Cases));
+	if ( T->Cases >= MinLeaf )
+	{
+	    if ( (Errors = T->Cases - T->ClassDist[T->Leaf]) >= 0.05 )
+	    {
+		fprintf(Of, "/%.8g", P1(Errors));
+	    }
+	}
+	putc(')', Of);
+    }
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Print a node T with offset Sh, branch value v, and continue	 */
+/*									 */
+/*************************************************************************/
+
+
+void ShowBranch(int Sh, Tree T, DiscrValue v, DiscrValue BrNo)
+/*   ----------  */
+{
+    DiscrValue	Pv, Last;
+    Attribute	Att;
+    Boolean	FirstValue;
+    int		TextWidth, Skip, Values, i, Extra;
+    char	CVS1[20], CVS2[20];
+
+    Att = T->Tested;
+
+    switch ( T->NodeType )
+    {
+	case BrDiscr:
+
+	    Indent(Sh, BrNo);
+
+	    fprintf(Of, "%s = %s:", AttName[Att], AttValName[Att][v]);
+
+	    break;
+
+	case BrThresh:
+
+	    Indent(Sh, BrNo);
+
+	    fprintf(Of, "%s", AttName[Att]);
+
+	    if ( v == 1 )
+	    {
+		fprintf(Of, " = N/A:");
+	    }
+	    else
+	    if ( T->Lower != T->Upper )
+	    {
+		if ( v == 2 )
+		{
+		    CValToStr(T->Lower, Att, CVS1);
+		    CValToStr(T->Mid  , Att, CVS2);
+		    fprintf(Of, " <= %s (%s):", CVS1, CVS2);
+		}
+		else
+		{
+		    CValToStr(T->Upper, Att, CVS1);
+		    CValToStr(T->Mid  , Att, CVS2);
+		    fprintf(Of, " >= %s (%s):", CVS1, CVS2);
+		}
+	    }
+	    else
+	    {
+		CValToStr(T->Cut, Att, CVS1);
+		fprintf(Of, " %s %s:", ( v == 2 ? "<=" : ">" ), CVS1);
+	    }
+
+	    break;
+
+	case BrSubset:
+
+	    /*  Count values at this branch  */
+
+	    Values = Elements(Att, T->Subset[v], &Last);
+	    if ( ! Values ) return;
+
+	    Indent(Sh, BrNo);
+
+	    if ( Values == 1 )
+	    {
+		fprintf(Of, "%s = %s:", AttName[Att], AttValName[Att][Last]);
+		break;
+	    }
+
+	    if ( Ordered(Att) )
+	    {
+		/*  Find first value  */
+
+		for ( Pv = 1 ; ! In(Pv, T->Subset[v]) ; Pv++ )
+		    ;
+
+		fprintf(Of, "%s %s [%s-%s]:", AttName[Att], T_InRange,
+			AttValName[Att][Pv], AttValName[Att][Last]);
+		break;
+	    }
+
+	    fprintf(Of, "%s %s {", AttName[Att], T_ElementOf);
+	    FirstValue = true;
+	    Skip = CharWidth(AttName[Att]) + CharWidth(T_ElementOf) + 3;
+	    TextWidth = Skip + Sh * TabSize;
+
+	    ForEach(Pv, 1, Last)
+	    {
+		if ( In(Pv, T->Subset[v]) )
+		{
+		    /*  Find number of characters after this element  */
+
+		    if ( Pv != Last || T->Branch[v]->NodeType )
+		    {
+			Extra = 1;				/* for ":" */
+		    }
+		    else
+		    {
+			Extra = 2				/* for ": " */
+				+ CharWidth(ClassName[T->Branch[v]->Leaf])
+				+ 3				/* for " ()" */
+				+ Digits(T->Cases)
+				+ ( T->Errors < 0.05 ?  0 :
+						1		/* for "/" */
+						+ Digits(T->Errors) );
+		    }
+
+		    if ( ! FirstValue &&
+			 TextWidth + CharWidth(AttValName[Att][Pv]) +
+			     Extra + 1 > Width )
+		    {
+		  	Indent(Sh, 0);
+			fprintf(Of, "%s",
+				( LastBranch[Sh+1] && ! T->Branch[v]->NodeType ?
+				  "    " : ":   " ));
+			ForEach(i, 5, Skip) putc(' ', Of);
+
+			TextWidth = Skip + Sh * TabSize;
+			FirstValue = true;
+		    }
+
+		    fprintf(Of, "%s%c",
+				AttValName[Att][Pv], Pv == Last ? '}' : ',');
+		    TextWidth += CharWidth(AttValName[Att][Pv]) + 1;
+		    FirstValue = false;
+		}
+	    }
+	    putc(':', Of);
+    }
+
+    Show(T->Branch[v], Sh+1);
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Count the elements in a subset and record the last		 */
+/*									 */
+/*************************************************************************/
+
+
+DiscrValue Elements(Attribute Att, Set S, DiscrValue *Last)
+/*         --------  */
+{
+    DiscrValue Pv, Values=0;
+
+    ForEach(Pv, 1, MaxAttVal[Att])
+    {
+	if ( In(Pv, S) )
+	{
+	    *Last = Pv;
+	    Values++;
+	}
+    }
+
+    return Values;
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Find the approximate maximum single line size for non-leaf	 */
+/*	subtree T							 */
+/*									 */
+/*************************************************************************/
+
+
+int MaxLine(Tree T)
+/*  -------  */
+{
+    Attribute	Att;
+    DiscrValue	v, vv;
+    int		Ll, One, MaxLl=0;
+
+    Att = T->Tested;
+
+    /*  First find the max length of the line excluding tested att  */
+
+    ForEach(v, 1, T->Forks)
+    {
+	switch ( T->NodeType )
+	{
+	    case BrThresh:
+		if ( TStampVal(Att) )
+		{
+		    Ll = ( T->Lower != T->Upper ? 41 : 19 );
+		}
+		else
+		if ( DateVal(Att) )
+		{
+		    Ll = ( T->Lower != T->Upper ? 23 : 10 );
+		}
+		else
+		if ( TimeVal(Att) )
+		{
+		    Ll = ( T->Lower != T->Upper ? 19 : 8 );
+		}
+		else
+		{
+		    Ll = ( T->Lower != T->Upper ? 11 : 4 );
+		}
+		break;
+
+	    case BrDiscr:
+		if ( Ordered(Att) )
+		{
+		    vv = T->Cut;
+	
+		    switch ( v )
+		    {
+			case 1:
+			    Ll = 3;
+			    break;
+
+			case 2:
+			    Ll = CharWidth(AttValName[Att][2]);
+			    if ( vv != 2 )
+			    {
+				Ll += CharWidth(AttValName[Att][vv])+1;
+			    }
+			    break;
+
+			case 3:
+			    Ll = CharWidth(AttValName[Att][MaxAttVal[Att]]);
+			    if ( vv != MaxAttVal[Att] - 1 )
+			    {
+				Ll += CharWidth(AttValName[Att][vv+1])+1;
+			    }
+		    }
+		}
+		else
+		{
+		    Ll = CharWidth(AttValName[Att][v]) + 1;
+		}
+		break;
+
+	    case BrSubset: /* difficult! */
+		Ll = 0;
+		ForEach(vv, 1, MaxAttVal[Att])
+		{
+		    if ( In(vv,T->Subset[v]) )
+		    {
+			One = CharWidth(AttValName[Att][vv]) + 6;
+			if ( One > Ll ) Ll = One;
+		    }
+		}
+	}
+
+	/*  Check whether ends in leaf  */
+
+	if ( ! T->Branch[v]->NodeType &&
+	     ( v > 1 || T->Branch[v]->Cases > 0.01 ) )
+	{
+	    Ll += CharWidth(ClassName[T->Branch[v]->Leaf]) + 6;
+	}
+
+	if ( Ll > MaxLl ) MaxLl = Ll;
+    }
+
+    return CharWidth(AttName[Att]) + 4 + MaxLl;
+}
+
+
+
+/*************************************************************************/
+/*								   	 */
+/*	Indent Sh columns					  	 */
+/*								  	 */
+/*************************************************************************/
+
+
+void Indent(int Sh, int BrNo)
+/*   ------  */
+{
+    int	i;
+
+    fprintf(Of, "\n");
+    for ( i = 1 ; i <= Sh ; i++ )
+    {
+	fprintf(Of, "%s", ( i == Sh && BrNo == 1 ? ":..." :
+			    LastBranch[i] ? "    " : ":   " ));
+    }
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Free up space taken up by tree T				 */
+/*									 */
+/*************************************************************************/
+
+
+void FreeTree(Tree T)
+/*   --------  */
+{
+    DiscrValue v;
+
+    if ( ! T ) return;
+
+    if ( T->NodeType )
+    {
+	ForEach(v, 1, T->Forks)
+	{
+	    FreeTree(T->Branch[v]);
+	}
+
+	Free(T->Branch);
+
+	if ( T->NodeType == BrSubset )
+	{
+	    FreeVector((void **) T->Subset, 1, T->Forks);
+	}
+
+    }
+
+    Free(T->ClassDist);
+    Free(T);
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Construct a leaf in a given node				 */
+/*									 */
+/*************************************************************************/
+
+
+Tree Leaf(double *Freq, ClassNo NodeClass, CaseCount Cases, CaseCount Errors)
+/*   ----  */
+{
+    Tree	Node;
+    ClassNo	c;
+
+    Node = AllocZero(1, TreeRec);
+
+    Node->ClassDist = AllocZero(MaxClass+1, CaseCount);
+    if ( Freq )
+    {
+	ForEach(c, 1, MaxClass)
+	{
+	    Node->ClassDist[c] = Freq[c];
+	}
+    }
+
+    Node->NodeType	= 0;
+    Node->Leaf		= NodeClass;
+    Node->Cases		= Cases;
+    Node->Errors	= Errors;
+
+    return Node;
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Insert branches in a node 		         		 */
+/*									 */
+/*************************************************************************/
+
+
+void Sprout(Tree T, DiscrValue Branches)
+/*   ------  */
+{
+    T->Forks = Branches;
+    T->Branch = AllocZero(Branches+1, Tree);
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Remove branches etc from a node					 */
+/*									 */
+/*************************************************************************/
+
+
+void UnSprout(Tree T)
+/*   --------  */
+{
+    DiscrValue	v;
+
+    ForEach(v, 1, T->Forks)
+    {
+	FreeTree(T->Branch[v]);
+    }
+    Free(T->Branch);					T->Branch = Nil;
+
+    if ( T->NodeType == BrSubset )
+    {
+	FreeVector((void **) T->Subset, 1, T->Forks);	T->Subset = Nil;
+    }
+
+    T->Forks = T->NodeType = 0;
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Count the non-null leaves in a tree				 */
+/*									 */
+/*************************************************************************/
+
+
+int TreeSize(Tree T)
+/*  --------  */
+{
+    int		Sum=0;
+    DiscrValue	v;
+
+    if ( T->NodeType )
+    {
+	ForEach(v, ( EmptyNA(T) ? 2 : 1 ), T->Forks)
+	{
+	    Sum += TreeSize(T->Branch[v]);
+	}
+
+	return Sum;
+    }
+
+    return ( T->Cases >= MinLeaf ? 1 : 0 );
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Count the non-null leaves in a tree that may contain		 */
+/*	compressed branches via CompressBranches()			 */
+/*									 */
+/*************************************************************************/
+
+
+int ExpandedLeafCount(Tree T)
+/*  -----------------  */
+{
+    int		Sum=0;
+    DiscrValue	v, Dummy;
+
+    if ( ! T->NodeType )
+    {
+	return 1;
+    }
+
+    ForEach(v, 1, T->Forks)
+    {
+	if ( T->Branch[v]->Cases < MinLeaf ) continue;
+
+	if ( T->NodeType == BrSubset && ! T->Branch[v]->NodeType )
+	{
+	    Sum += Elements(T->Tested, T->Subset[v], &Dummy);
+	}
+	else
+	{
+	    Sum += ExpandedLeafCount(T->Branch[v]);
+	}
+    }
+
+    return Sum;
+}
+
+
+
+/*************************************************************************/
+/*                                                                	 */
+/*	Find the maximum depth of a tree				 */
+/*                                                                	 */
+/*************************************************************************/
+
+
+int TreeDepth(Tree T)
+/*  ---------  */
+{
+    DiscrValue	v;
+    int		Subtree, MaxSubtree=0;
+
+    if ( T->NodeType )
+    {
+	ForEach(v, 1, T->Forks)
+	{
+	    Subtree = TreeDepth(T->Branch[v]);
+	    if ( Subtree > MaxSubtree ) MaxSubtree = Subtree;
+	}
+    }
+
+    return MaxSubtree + 1;
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Return a copy of tree T						 */
+/*									 */
+/*************************************************************************/
+
+
+Tree CopyTree(Tree T)
+/*   --------  */
+{
+    DiscrValue	v;
+    Tree	New;
+    int		Bytes;
+
+    New = Alloc(1, TreeRec);
+    memcpy(New, T, sizeof(TreeRec));
+
+    New->ClassDist = Alloc(MaxClass+1, CaseCount);
+    memcpy(New->ClassDist, T->ClassDist, (MaxClass + 1) * sizeof(CaseCount));
+
+    if ( T->NodeType == BrSubset )
+    {
+	Bytes = (MaxAttVal[T->Tested]>>3) + 1;
+
+	New->Subset = Alloc(T->Forks+1, Set);
+	ForEach(v, 1, T->Forks)
+	{
+	    New->Subset[v] = Alloc(Bytes, unsigned char);
+	    memcpy(New->Subset[v], T->Subset[v], Bytes);
+	}
+    }
+
+    if ( T->NodeType )
+    {
+	New->Branch = AllocZero(T->Forks+1, Tree);
+	ForEach(v, 1, T->Forks)
+	{
+	    New->Branch[v] = CopyTree(T->Branch[v]);
+	}
+    }
+
+    return New;
+}