name: Hypothesis

synopsis:

g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_search.a

#include <Hypothesis.h>

~Hypothesis();
Hypothesis();
Hypothesis(const Hypothesis& copy_hyp);
Hypothesis(const String& hyp);

quick start:

#include <Hypothesis.h>

Trace new_trace;
float socre = -793.83;
Hypothesis hyp(new_trace, score);

Stack stack;
stack.push(&hypothesis);

description:

The Hypothesis class represents a word level search hypothesis in the stack search algorithm. It consists of a trace pointer and an estimate of the total score of this search hypothesis. The Hypothesis object is stored in the PriorityQueue of the StackSearch object. It is not enough to store only a Trace pointer in the PriorityQueue of StackSearch, because the Trace contains only exact score of the path so far. Since we need an estimate of the total score, we use Hypothesis, which contains an estimate of total score of the path (the score to the goal node).

dependencies:

Trace

public constants:

define the class name:
```
static const String CLASS_NAME;
```

error codes:

error code indicating a general error:
```
static const long ERR = 90200;
```
error code indicating an i/o error:
```
static const long READ = 90201;
```

protected data:

hypothesis score, estimates distance to taret

 float score_d;

pointer to word level trace

 Trace* trace_d;

memory manager
```
static MemoryManager mgr_d;
```
debug level
```
static Integral::DEBUG debug_level_d;
```

required public methods:

static methods:

static const String& name();

static boolean diagnose(Integral::DEBUG debug_level);

debug methods:

boolean debug(const unichar* message) const;

static boolean setDebug(Integral::DEBUG debug_level);

destructor/constructor(s):

~Hypothesis();

Hypothesis(Trace* trace = NULL, float score = 0);

Hypothesis(const Hypothesis& arg);

assign methods:

boolean assign(const Hypothesis& copy_hyp);

operator= (assignment) methods:

Hypothesis& operator = (const Hypothesis& arg);

relational methods:

boolean operator > (const Hypothesis& arg);

boolean operator < (const Hypothesis& arg);

i/o methods:

long sofSize() const;

boolean read(Sof& sof, long tag, const String& name = CLASS_NAME);

boolean write(Sof& sof, long tag, const String& name = CLASS_NAME) const;

boolean readData(Sof& sof, const String& pname = String::EMPTY, long size = SofParser::FULL_OBJECT, boolean param = true, boolean nested = false);

boolean writeData(Sof& sof, const String& pname = DEF_PARAM) const;

memory management methods:

static void* operator new(size_t size);

static void* operator new[](size_t size);

static void operator delete(void* ptr);

static void operator delete[](void* ptr);

static boolean setGrowSize(long grow_size);

boolean clear(Integral::CMODE ctype = Integral::DEF_CMODE);

class-specific public methods:

get methods:
```
float getScore();
```
```
Trace* getTrace();
```

examples:

none

notes:

none