You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
760 lines
18 KiB
760 lines
18 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1997 - 1997
|
|
//
|
|
// File: bntest.cpp
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
//
|
|
// BNTEST.CPP
|
|
//
|
|
#include <windows.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
#include <math.h>
|
|
#include <float.h>
|
|
|
|
#include "bnparse.h" // Parser class
|
|
#include "bnreg.h" // Registry management
|
|
#include "testinfo.h" // Output test file generation
|
|
#include "distdense.hxx" // Distribution classes
|
|
#include "distsparse.h"
|
|
|
|
#ifdef TIME_DYN_CASTS
|
|
// Global variable containing count of calls to all forms of DynCastThrow function template
|
|
int g_cDynCasts = 0;
|
|
#endif
|
|
|
|
enum EFN // File name in file name array
|
|
{
|
|
EFN_IN, // input DSC file
|
|
EFN_OUT, // output DSC file
|
|
EFN_INFER // output inference test file (see testinfo.cpp for format)
|
|
};
|
|
|
|
static
|
|
inline
|
|
double RNan ()
|
|
{
|
|
double rnan = sqrt(-1.0);
|
|
#ifndef NTALPHA
|
|
assert( _isnan( rnan ) );
|
|
#endif
|
|
return rnan;
|
|
}
|
|
|
|
static
|
|
inline
|
|
bool BFlag ( ULONG fCtl, ULONG fFlag )
|
|
{
|
|
return (fCtl & fFlag) > 0;
|
|
}
|
|
|
|
static
|
|
void usage ()
|
|
{
|
|
cout << "\nBNTEST: Belief Network Test program"
|
|
<< "\nCommand line:"
|
|
<< "\n\tbntest [options] <input.DSC> [/s <output.DSC>] [/p <output.DMP>]"
|
|
<< "\nOptions:"
|
|
<< "\n\t/v\t\tverbose output"
|
|
<< "\n\t/c\t\tclique the network"
|
|
<< "\n\t/e\t\ttest CI network expansion"
|
|
<< "\n\t/inn\t\ttest inference; nn = iterations (default 1)"
|
|
<< "\n\t/p <filename>\twrite inference output (.dmp) file (sets /i)"
|
|
<< "\n\t/s <filename>\trewrite input DSC into output file"
|
|
<< "\n\t/t\t\tdisplay start and stop times"
|
|
<< "\n\t/x\t\tpause at various stages (for memory measurement)"
|
|
<< "\n\t/n\t\tuse symbolic names in inference output (default is full)"
|
|
<< "\n\t/y\t\tclone the network (write cloned version if /s)"
|
|
<< "\n\t/u\t\tinclude entropic utility records in /p output"
|
|
<< "\n\t/b\t\tinclude troubleshooting recommendations in /p output"
|
|
<< "\n\t/r\t\tstore property types in Registry for persistence"
|
|
<< "\n\t/b\t\tcompute troubleshooting recommendations"
|
|
<< "\n\t/z\t\tshow inference engine statistics"
|
|
<< "\n\t/m<nnnnnn>\tset maximum estimated inference engine size"
|
|
<< "\n\t/a<n.n>\t\tflag impossible evidence with numeric value"
|
|
<< "\n\nInput DSC is read and parsed; errors and warnings go to stderr."
|
|
<< "\nParse errors stop testing. If cloning, output file is cloned version."
|
|
<< "\nIf CI expansion (/e), output (/s) has pre- and post- expansion versions."
|
|
<< "\nInference (/i or /p) takes precedence over CI expansion (/e)."
|
|
<< "\nInference output (/p) writes file in common format with DXTEST."
|
|
<< "\nCliquing (/c) just creates and destroys junction tree."
|
|
<< "\n";
|
|
}
|
|
|
|
static
|
|
void die( SZC szcFormat, ... )
|
|
{
|
|
ZSTR zsMsg;
|
|
|
|
va_list valist;
|
|
va_start(valist, szcFormat);
|
|
|
|
zsMsg.Vsprintf( szcFormat, valist );
|
|
|
|
va_end(valist);
|
|
|
|
cerr << "\nBNTEST error: "
|
|
<< zsMsg.Szc()
|
|
<< "\n";
|
|
exit(1);
|
|
}
|
|
|
|
|
|
// Show the debugging build options
|
|
static
|
|
void showOptions ( ULONG fCtl )
|
|
{
|
|
bool bComma = false;
|
|
ZSTR zs = TESTINFO::ZsOptions( fCtl );
|
|
cout << "(options: "
|
|
<< zs;
|
|
|
|
bComma = zs.length() > 0;
|
|
|
|
// Show DYNAMIC CAST option
|
|
if ( bComma )
|
|
cout << ",";
|
|
cout <<
|
|
#ifdef USE_STATIC_CAST
|
|
"STATICCAST"
|
|
#else
|
|
"DYNCAST"
|
|
#endif
|
|
;
|
|
bComma = true;
|
|
|
|
// Show DUMP option
|
|
#ifdef DUMP
|
|
if ( bComma )
|
|
cout << ",";
|
|
cout << "DUMP";
|
|
bComma = true;
|
|
#endif
|
|
|
|
// Show DEBUG option
|
|
#ifdef _DEBUG
|
|
if ( bComma )
|
|
cout << ",";
|
|
cout << "DEBUG";
|
|
bComma = true;
|
|
#endif
|
|
|
|
cout << ")";
|
|
}
|
|
|
|
// Show memory leaks for primary object types, if any
|
|
static
|
|
void showResiduals ()
|
|
{
|
|
#ifdef _DEBUG
|
|
if (GEDGE::CNew() + GNODE::CNew() + GNODE::CNew() )
|
|
{
|
|
cout << "\n(GEDGEs = "
|
|
<< GEDGE::CNew()
|
|
<< ", GNODESs = "
|
|
<< GNODE::CNew()
|
|
<< ", BNDISTs = "
|
|
<< GNODE::CNew()
|
|
<< ")";
|
|
}
|
|
if ( VMARGSUB::CNew() + MARGSUBREF::CNew() )
|
|
{
|
|
cout << "\n(VMARGSUBs = "
|
|
<< VMARGSUB::CNew()
|
|
<< ", MARGSUBREFs = "
|
|
<< MARGSUBREF::CNew()
|
|
<< ")";
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
static
|
|
void printResiduals ()
|
|
{
|
|
#ifdef _DEBUG
|
|
showResiduals();
|
|
#endif
|
|
#ifdef TIME_DYN_CASTS
|
|
cout << "\ntotal number of dynamic casts was "
|
|
<< g_cDynCasts;
|
|
#endif
|
|
}
|
|
|
|
// Display the message and pause if the "pause" option is active
|
|
inline
|
|
static
|
|
void pauseIf ( ULONG fCtl, SZC szcMsg )
|
|
{
|
|
if ( (fCtl & fPause) == 0 )
|
|
return;
|
|
showResiduals();
|
|
char c;
|
|
cout << "\n"
|
|
<< szcMsg
|
|
<< " (pause)"
|
|
;
|
|
cin.get(c);
|
|
}
|
|
|
|
// Display the phase message and, optionally, the time
|
|
typedef DWORD CTICKS;
|
|
|
|
inline
|
|
static
|
|
CTICKS showPhase ( ULONG fCtl, SZC szcPhase, CTICKS * ptmLast = NULL )
|
|
{
|
|
// Display the phase message
|
|
cout << "\n" << szcPhase;
|
|
CTICKS cticks = 0;
|
|
|
|
if ( fCtl & fShowTime )
|
|
{
|
|
// Save the current tick count
|
|
cticks = ::GetTickCount();
|
|
|
|
// Prepare to display the current date/time
|
|
time_t timeNow;
|
|
time(& timeNow);
|
|
ZSTR zsTime = ctime(&timeNow);
|
|
int cnl = zsTime.find( '\n' );
|
|
if ( cnl != 0 )
|
|
zsTime.resize( cnl );
|
|
cout << " " << zsTime;
|
|
|
|
// Display the elapsed time if we know it
|
|
if ( ptmLast && *ptmLast != 0 )
|
|
{
|
|
CTICKS ticksElapsed = cticks - *ptmLast;
|
|
cout << " (elapsed time "
|
|
<< ticksElapsed
|
|
<< " milliseconds)";
|
|
}
|
|
}
|
|
return cticks;
|
|
}
|
|
|
|
|
|
static
|
|
void testRegistry ( MBNET & mbnet )
|
|
{
|
|
BNREG bnr;
|
|
bnr.StorePropertyTypes( mbnet, true );
|
|
}
|
|
|
|
#ifdef TESTDIST
|
|
static void loadDistDenseFromMpcpdd ( DISTDENSE & ddense, const MPCPDD & mpcpdd )
|
|
{
|
|
ddense.AllocateParams();
|
|
|
|
CST cstNode = ddense.CstNode();
|
|
|
|
// Find the default vector in the map or create a uniform vector
|
|
const VLREAL * pvlrDefault = mpcpdd.PVlrDefault();
|
|
VLREAL vlrDefault;
|
|
if ( pvlrDefault )
|
|
{
|
|
vlrDefault = *pvlrDefault;
|
|
}
|
|
else
|
|
{
|
|
vlrDefault.resize( cstNode );
|
|
REAL rDefault = 1 / cstNode ;
|
|
vlrDefault = rDefault;
|
|
}
|
|
|
|
// Fill the dense array with the default value
|
|
UINT cParamgrp = ddense.Cparamgrp();
|
|
UINT igrp = 0;
|
|
for ( ; igrp < cParamgrp; igrp++ )
|
|
{
|
|
for ( UINT ist = 0; ist < cstNode; ist++ )
|
|
{
|
|
ddense.Param(ist, igrp) = vlrDefault[ist];
|
|
}
|
|
}
|
|
|
|
// Iterate over the sparse map, storing probabilities as parameters
|
|
const VCST & vcstParent = ddense.VcstParent();
|
|
VIST vist;
|
|
for ( MPCPDD::iterator mpitcpd = mpcpdd.begin();
|
|
mpitcpd != mpcpdd.end();
|
|
mpitcpd++ )
|
|
{
|
|
const VIMD & vimd = (*mpitcpd).first;
|
|
const VLREAL & vlr = (*mpitcpd).second;
|
|
// State vector size must match state space
|
|
assert( vlr.size() == cstNode );
|
|
// Parent dimensions must match dimension index
|
|
assert( vdimchk( vimd, vcstParent ) );
|
|
// Convert the vector of unsigneds to a vector of signeds
|
|
vdup( vist, vimd );
|
|
// Get the parameter group index
|
|
UINT igrp = ddense.Iparamgrp( vist );
|
|
// Copy the probabilities as parameters
|
|
for ( UINT ist = 0; ist < cstNode; ist++ )
|
|
{
|
|
ddense.Param(ist, igrp) = vlr[ist];
|
|
}
|
|
}
|
|
}
|
|
|
|
static void testDistDenseWithMpcpdd( DISTDENSE & ddense, const MPCPDD & mpcpdd )
|
|
{
|
|
}
|
|
|
|
static void loadDistSparseFromMpcpdd ( DISTSPARSE & dsparse, const MPCPDD & mpcpdd )
|
|
{
|
|
dsparse.Init( mpcpdd );
|
|
}
|
|
|
|
static void testDistSparseWithMpcpdd ( DISTSPARSE & dsparse, const MPCPDD & mpcpdd )
|
|
{
|
|
MPCPDD mpcpddNew;
|
|
dsparse.Fill( mpcpddNew );
|
|
|
|
assert( mpcpddNew == mpcpdd );
|
|
}
|
|
#endif
|
|
|
|
// Bind the model's distibutions and verify behavior of the DISTSPARSE
|
|
// and DISTDENSE classes.
|
|
static
|
|
void testDistributions ( MBNETDSC & mbnetdsc, ULONG fCtl )
|
|
{
|
|
|
|
#ifdef TESTDIST
|
|
|
|
// Bind the distributions
|
|
mbnetdsc.BindDistributions();
|
|
GOBJMBN * pgmobj;
|
|
for ( MBNETDSC::ITER mbnit( mbnetdsc, GOBJMBN::EBNO_NODE );
|
|
pgmobj = *mbnit ;
|
|
++mbnit)
|
|
{
|
|
ZSREF zsrName = mbnit.ZsrCurrent();
|
|
GNODEMBND * pgndd;
|
|
DynCastThrow( pgmobj, pgndd );
|
|
|
|
// Convert this node's distribution to a DISTDENSE and
|
|
// a DISTSPARSE, then compare them to the original
|
|
assert( pgndd->BHasDist() );
|
|
const BNDIST & bndist = pgndd->Bndist();
|
|
assert( bndist.BSparse() );
|
|
const MPCPDD & mpcpdd = bndist.Mpcpdd();
|
|
|
|
// Get the parent list for this node; convert to a state count vector
|
|
VPGNODEMBN vpgndParents;
|
|
VIMD vimdParents;
|
|
if ( ! pgndd->BGetVimd( vimdParents ) )
|
|
continue; // Skip non-discrete ensembles
|
|
VCST vcstParents;
|
|
vdup( vcstParents, vimdParents );
|
|
CST cStates = pgndd->CState();
|
|
|
|
DISTDENSE ddense( cStates, vcstParents );
|
|
DISTSPARSE dsparse( cStates, vcstParents );
|
|
loadDistDenseFromMpcpdd( ddense, mpcpdd );
|
|
testDistDenseWithMpcpdd( ddense, mpcpdd );
|
|
loadDistSparseFromMpcpdd( dsparse, mpcpdd );
|
|
testDistSparseWithMpcpdd( dsparse, mpcpdd );
|
|
}
|
|
|
|
// Release the distributions
|
|
mbnetdsc.ClearDistributions();
|
|
#endif
|
|
}
|
|
|
|
static
|
|
void
|
|
showInferStats ( TESTINFO & testinfo )
|
|
{
|
|
GOBJMBN_INFER_ENGINE * pInferEng = testinfo.Mbnet().PInferEngine();
|
|
assert( pInferEng );
|
|
GOBJMBN_CLIQSET * pCliqset = dynamic_cast<GOBJMBN_CLIQSET *>(pInferEng);
|
|
if ( pCliqset == NULL )
|
|
return; // Don't know how to get statistics from this inference engine
|
|
|
|
CLIQSETSTAT & cqstats = pCliqset->CqsetStat();
|
|
cout << "\n\nInference statistics: "
|
|
<< "\n\treloads = " << cqstats._cReload
|
|
<< "\n\tcollects = " << cqstats._cCollect
|
|
<< "\n\tset evidence = " << cqstats._cEnterEv
|
|
<< "\n\tget belief = " << cqstats._cGetBel
|
|
<< "\n\tprob norm = " << cqstats._cProbNorm
|
|
<< "\n"
|
|
;
|
|
}
|
|
|
|
static
|
|
void testInference ( ULONG fCtl, MBNETDSC & mbnet, SZC szcFnInfer, REAL rImposs )
|
|
{
|
|
ofstream ofs;
|
|
bool bOutput = (fCtl & fOutputFile) > 0 ;
|
|
int cPass = fCtl & fPassCountMask;
|
|
GOBJMBN_INFER_ENGINE * pInferEng = mbnet.PInferEngine();
|
|
assert( pInferEng );
|
|
|
|
if ( bOutput )
|
|
{
|
|
if ( szcFnInfer == NULL )
|
|
szcFnInfer = "infer.dmp";
|
|
ofs.open(szcFnInfer);
|
|
}
|
|
|
|
// Construct the test data container
|
|
TESTINFO testinfo( fCtl, mbnet, bOutput ? & ofs : NULL );
|
|
testinfo._rImposs = rImposs;
|
|
|
|
// Run the test
|
|
testinfo.InferTest();
|
|
|
|
if ( bOutput )
|
|
ofs.close();
|
|
|
|
if ( fCtl & fInferStats )
|
|
showInferStats( testinfo );
|
|
}
|
|
|
|
static
|
|
void testCliquingStart ( ULONG fCtl, MBNETDSC & mbnet, REAL rMaxEstSize = -1.0 )
|
|
{
|
|
#ifdef DUMP
|
|
if ( BFlag( fCtl, fVerbose ) )
|
|
{
|
|
cout << "\nBNTEST: BEGIN model before cliquing";
|
|
mbnet.Dump();
|
|
cout << "\nBNTEST: END model before cliquing\n";
|
|
}
|
|
#endif
|
|
mbnet.CreateInferEngine( rMaxEstSize );
|
|
|
|
#ifdef DUMP
|
|
if ( BFlag( fCtl, fVerbose ) )
|
|
{
|
|
cout << "\nBNTEST: BEGIN model after cliquing";
|
|
mbnet.Dump();
|
|
cout << "\nBNTEST: END model after cliquing\n";
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static
|
|
void testCliquingEnd ( MBNETDSC & mbnet, ULONG fCtl )
|
|
{
|
|
GOBJMBN_INFER_ENGINE * pInferEng = mbnet.PInferEngine();
|
|
if ( pInferEng == NULL )
|
|
return;
|
|
|
|
mbnet.DestroyInferEngine();
|
|
|
|
// For testing, nuke the topology
|
|
mbnet.DestroyTopology( true );
|
|
// Create arcs from the given conditional probability distributions
|
|
mbnet.CreateTopology();
|
|
// For testing, nuke the topology
|
|
mbnet.DestroyTopology( false );
|
|
}
|
|
|
|
static
|
|
void testParser (
|
|
ULONG fCtl,
|
|
SZC rgfn[],
|
|
REAL rMaxEstSize = -1.0,
|
|
REAL rImposs = -1.0 )
|
|
{
|
|
SZC szcFn = rgfn[EFN_IN];
|
|
SZC szcFnOut = rgfn[EFN_OUT];
|
|
SZC szcFnInfer = rgfn[EFN_INFER];
|
|
|
|
// Instantiate the belief network
|
|
MBNETDSC mbnet;
|
|
|
|
// See if there's an output file to write a DSC into
|
|
FILE * pfOut = NULL;
|
|
if ( (fCtl & fSaveDsc) > 0 && szcFnOut != NULL )
|
|
{
|
|
pfOut = fopen(szcFnOut,"w");
|
|
if ( pfOut == NULL )
|
|
die("error creating output DSC file \'%s\'", szcFnOut);
|
|
}
|
|
|
|
// Input file wrapper object
|
|
PARSIN_DSC flpIn;
|
|
// Output file wrapper object
|
|
PARSOUT_STD flpOut(stderr);
|
|
|
|
// Construct the parser; errors go to 'stderr'
|
|
DSCPARSER parser(mbnet, flpIn, flpOut);
|
|
|
|
UINT cError, cWarning;
|
|
|
|
try
|
|
{
|
|
// Attempt to open the file
|
|
if ( ! parser.BInitOpen( szcFn ) )
|
|
die("unable to access input file");
|
|
|
|
pauseIf( fCtl, "input DSC file open" );
|
|
|
|
// Parse the file
|
|
if ( ! parser.BParse( cError, cWarning ) )
|
|
die("parse failure; %d errors, %d warnings", cError, cWarning);
|
|
if ( cWarning )
|
|
cout << "\nBNTEST: file "
|
|
<< szcFn
|
|
<< " had "
|
|
<< cWarning
|
|
<< " warnings\n";
|
|
|
|
if ( BFlag( fCtl, fReg ) )
|
|
testRegistry( mbnet );
|
|
|
|
pauseIf( fCtl, "DSC file read and processed" );
|
|
|
|
if ( BFlag( fCtl, fDistributions ) )
|
|
{
|
|
testDistributions( mbnet, fCtl );
|
|
}
|
|
|
|
// If requested, test cloning
|
|
if ( BFlag( fCtl, fClone ) )
|
|
{
|
|
MBNETDSC mbnetClone;
|
|
mbnetClone.Clone( mbnet );
|
|
if ( pfOut )
|
|
mbnetClone.Print( pfOut );
|
|
}
|
|
else
|
|
// If requested, write out a DSC file
|
|
if ( pfOut )
|
|
{
|
|
mbnet.Print( pfOut );
|
|
}
|
|
|
|
// Test cliquing if requested (/c) or required (/i)
|
|
if ( BFlag( fCtl, fCliquing ) || BFlag( fCtl, fInference ) )
|
|
{
|
|
testCliquingStart( fCtl, mbnet, rMaxEstSize );
|
|
|
|
pauseIf( fCtl, "Cliquing completed" );
|
|
|
|
if ( BFlag( fCtl, fInference ) )
|
|
{
|
|
// Generate inference results (/i)
|
|
testInference( fCtl, mbnet, szcFnInfer, rImposs );
|
|
pauseIf( fCtl, "Inference output generation completed" );
|
|
}
|
|
testCliquingEnd( mbnet, fCtl ) ;
|
|
|
|
pauseIf( fCtl, "Cliquing and inference completed" );
|
|
}
|
|
else
|
|
// Test if CI expansion requested (/e)
|
|
if ( BFlag( fCtl, fExpand ) )
|
|
{
|
|
// Perform CI expansion on the network.
|
|
mbnet.ExpandCI();
|
|
pauseIf( fCtl, "Network expansion complete" );
|
|
|
|
// If output file generation, do "before" and "after" expansion and reversal
|
|
if ( pfOut )
|
|
{
|
|
fprintf( pfOut, "\n\n//////////////////////////////////////////////////////////////" );
|
|
fprintf( pfOut, "\n// Network After Expansion //" );
|
|
fprintf( pfOut, "\n//////////////////////////////////////////////////////////////\n\n" );
|
|
mbnet.Print( pfOut );
|
|
}
|
|
// Undo the expansion
|
|
mbnet.UnexpandCI();
|
|
if ( pfOut )
|
|
{
|
|
fprintf( pfOut, "\n\n//////////////////////////////////////////////////////////////" );
|
|
fprintf( pfOut, "\n// Network After Expansion Reversal //" );
|
|
fprintf( pfOut, "\n//////////////////////////////////////////////////////////////\n\n" );
|
|
mbnet.Print( pfOut );
|
|
}
|
|
}
|
|
|
|
// For testing, nuke the topology
|
|
mbnet.DestroyTopology();
|
|
}
|
|
catch ( GMException & exbn )
|
|
{
|
|
die( exbn.what() );
|
|
}
|
|
|
|
if ( pfOut )
|
|
fclose( pfOut );
|
|
}
|
|
|
|
|
|
int main (int argc, char * argv[])
|
|
{
|
|
int iArg ;
|
|
short cPass = 1;
|
|
int cFile = 0 ;
|
|
const int cFnMax = 10 ;
|
|
SZC rgfn [cFnMax+1] ;
|
|
ULONG fCtl = 0;
|
|
REAL rMaxEstSize = -1.0;
|
|
REAL rImposs = RNan();
|
|
|
|
for ( int i = 0 ; i < cFnMax ; i++ )
|
|
{
|
|
rgfn[i] = NULL ;
|
|
}
|
|
for ( iArg = 1 ; iArg < argc ; iArg++ )
|
|
{
|
|
switch ( argv[iArg][0] )
|
|
{
|
|
case '/':
|
|
case '-':
|
|
{
|
|
char chOpt = toupper( argv[iArg][1] ) ;
|
|
switch ( chOpt )
|
|
{
|
|
case 'V':
|
|
// Provide verbose output
|
|
fCtl |= fVerbose;
|
|
break;
|
|
case 'C':
|
|
// Perform cliquing
|
|
fCtl |= fCliquing;
|
|
break;
|
|
case 'E':
|
|
// Test network CI expansion
|
|
fCtl |= fExpand;
|
|
break;
|
|
case 'I':
|
|
// Exercise inference and optionally write the results in a standard form
|
|
{
|
|
int c = atoi( & argv[iArg][2] );
|
|
if ( c > 0 )
|
|
{
|
|
fCtl |= fMulti;
|
|
cPass = c;
|
|
}
|
|
fCtl |= fInference;
|
|
break;
|
|
}
|
|
case 'P':
|
|
// Get the name of the inference output file
|
|
fCtl |= fOutputFile | fInference;
|
|
if ( ++iArg == argc )
|
|
die("no output inference result file name given");
|
|
rgfn[EFN_INFER] = argv[iArg];
|
|
break;
|
|
case 'S':
|
|
// Write the input DSC file as an output file
|
|
fCtl |= fSaveDsc;
|
|
if ( ++iArg == argc )
|
|
die("no output DSC file name given");
|
|
rgfn[EFN_OUT] = argv[iArg];
|
|
break;
|
|
case 'T':
|
|
// Display start and stop times
|
|
fCtl |= fShowTime;
|
|
break;
|
|
case 'X':
|
|
// Pause at times during execution to allow the user to measure
|
|
// memory usage
|
|
fCtl |= fPause;
|
|
break;
|
|
case 'Y':
|
|
// Clone the network after loading
|
|
fCtl |= fClone;
|
|
break;
|
|
case 'N':
|
|
// Write the symbolic name into the inference exercise output file
|
|
// instead of the default full name.
|
|
fCtl |= fSymName;
|
|
break;
|
|
case 'U':
|
|
// Compute utilities using inference
|
|
fCtl |= fUtil | fInference;
|
|
break;
|
|
case 'B':
|
|
// Compute troubleshooting utilities using inference
|
|
fCtl |= fTSUtil | fInference;
|
|
break;
|
|
case 'R':
|
|
fCtl |= fReg;
|
|
break;
|
|
case 'Z':
|
|
fCtl |= fInferStats;
|
|
break;
|
|
case 'M':
|
|
{ // Get the maximum estimated clique tree size
|
|
float f = atof( & argv[iArg][2] );
|
|
if ( f > 0.0 )
|
|
rMaxEstSize = f;
|
|
break;
|
|
}
|
|
case 'A':
|
|
{
|
|
if ( strlen( & argv[iArg][2] ) > 0 )
|
|
{
|
|
rImposs = atof( & argv[iArg][2] );
|
|
}
|
|
fCtl |= fImpossible;
|
|
break;
|
|
}
|
|
case 'D':
|
|
fCtl |= fDistributions;
|
|
break;
|
|
|
|
default:
|
|
die("unrecognized option") ;
|
|
break ;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if ( cFile == 0 )
|
|
rgfn[cFile++] = argv[iArg] ;
|
|
else
|
|
die("too many file names given");
|
|
break ;
|
|
}
|
|
}
|
|
|
|
fCtl |= fPassCountMask & cPass;
|
|
|
|
|
|
if ( cFile == 0 )
|
|
{
|
|
usage();
|
|
return 0;
|
|
}
|
|
|
|
// Display options and the debugging build mode
|
|
showOptions( fCtl );
|
|
|
|
// Display the start message
|
|
CTICKS tmStart = showPhase( fCtl, "BNTEST starts" );
|
|
|
|
if ( rMaxEstSize > 0.0 )
|
|
cout << "\nMaximum clique tree size estimate is " << rMaxEstSize;
|
|
|
|
// Test the parser and everything else
|
|
testParser( fCtl, rgfn, rMaxEstSize, rImposs );
|
|
|
|
// Display the stop message
|
|
showPhase( fCtl, "BNTEST completed", & tmStart );
|
|
|
|
// Print memory leaks of primary objects, if any
|
|
printResiduals();
|
|
|
|
cout << "\n";
|
|
|
|
return 0;
|
|
}
|
|
|