PUBLIC

BaseCostC::BaseCostC(TraceC) BaseCostC::~BaseCostC(void) BaseCostC::TrapUndefinedVirtual(const char *) BaseCostC::Energy(int,int,int,int) BaseCostC::Energy(const HardAssignC &) BaseCostC::Energy(const SoftAssignC &) BaseCostC::GetMFTSupport(SoftAssignC &,int,const SoftAssignC &) BaseCostC::GetMFTSupport(const SoftAssignC &) BaseCostC::GetGradAssSupport(SoftAssignC &,int,const SoftAssignC &) BaseCostC::GetGradAssSupport(const SoftAssignC &) BaseCostC::GetEnergy(int,int,const HardAssignC &) BaseCostC::LoadEnergy(int,const HardAssignC &) TraceC::TraceC(int,ostream &) TraceC::~TraceC(void) TraceC::TraceC(const TraceC &)

BaseCostC
include	"amma/BaseCost.hh"
User Level:	Default
Library:	CombOpt
Example:	doNumClassComb.cc
Section:	default.Andrew Stoddart
In Scope:	std

Comments:
Base Class of the Cost Function of Combinatorial Optimizers ------------------------------------------------------- Name : $RCSfile: BaseCost.hh,v $ Library : Description: Modified : see list of Revision below Created : see initial Revision below Author : Kjell Brunnstrom and Andrew Stoddart ------------------------------------------------------------------------- ------------------------------------------------------------------------- An earlier version of this code was much more "elegant" but led to multiple inheritance. This version eliminates that and is much simpler. It does not use abstract virtual functions, but simply traps virtual functions not overridden at runtime. ------------------------------------------------------------------------- ------------------------------------------------------------------------- -------------------------------------------------------------------------

public TraceC

SimplePairwiseCostC

BaseCostC(TraceC t = TraceC())

Constructor

~BaseCostC()

virtual destructor More universal functions ------------------------

void TrapUndefinedVirtual(const char * fname)

the crude but efective way to catch virtual functions that have not been overridden

double Energy(int i,int j,int a,int b)

return the pairwise energy

double Energy(const HardAssignC & r)

return the energy of the overall labelling It is assumed that this is slower and to be used sparingly

double Energy(const SoftAssignC & r)

return the energy of the overall labelling It is assumed that this is slower and to be used sparingly Mean Field Theory -----------------

void GetMFTSupport(SoftAssignC & q,int i,const SoftAssignC & work)

returns the support for one object

SoftAssignC GetMFTSupport(const SoftAssignC & work)

returns the support Graduated assignment --------------------

void GetGradAssSupport(SoftAssignC & q,int i,const SoftAssignC & work)

returns the support for one object

SoftAssignC GetGradAssSupport(const SoftAssignC & work)

returns the support Simulated Annealing -------------------

double GetEnergy(int i,int a,const HardAssignC & r)

get the energy for object i with label a, or at least the part of the energy affected by changing labels on object i only

RealSArray1dC LoadEnergy(int i,const HardAssignC & r)

Load up the array work with the energies for each label of object i given global assignment r

Inline TraceC(int tl = NoTrace,ostream & os = cout)

Constructor

Inline ~TraceC()

Destructor

Inline TraceC(const TraceC & t)

Copy Constructor