name: UniformModel

synopsis:

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

#include <UniformModel.h>

UniformModel(MODE mode = DEF_MODE);
UniformModel(const UniformModel& arg);
boolean eq(const UniformModel& arg) const;
boolean assign(const UniformModel& arg);
boolean setMin(VectorFloat& arg);
boolean setMax(VectorFloat& arg);

quick start:

UniformModel model;
VectorFloat min;
min.assign(L"-2, -1, -3");
model.setMin(min);
VectorFloat max(L"1, 2, 0");
model.setMax(max);

description:

The UniformModel class is used to calculate the likelihood of a vector modeled by a uniform distribution. The density function is defined as follows:

               1 
  p(x) = -----------------  ,  min < x < max
          Area(max - min)

                0           ,  otherwise

where the area is computed as a product of rectangular regions in an N-dimensional space.

dependencies:

public constants:

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

define i/o related constants:

static const String DEF_PARAM;

static const String PARAM_MIN;

static const String PARAM_MAX;

error codes:

error code indicating UniformModel class general error:
```
static const long ERR = 60400;
```

protected data:

variables to describe the range:

VectorFloat min_d;

VectorFloat max_d;

probability distribution scale factor:

float scale_d;

define the memory manager:
```
static MemoryManager mgr_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;
```
setDebug is inherited from base class

destructor/constructor(s):

~UniformModel();

UniformModel(MODE mode = DEF_MODE);

UniformModel(const UniformModel& arg);

assign methods:

boolean assign(const UniformModel& arg);

operator= methods:

UniformModel& operator=(const UniformModel& 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 readAccumulator(Sof& sof, long tag, const String& name = CLASS_NAME);

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

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

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

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

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

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

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

equality methods:

boolean eq(const UniformModel& arg) 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 cmode = Integral::DEF_CMODE);

class-specific public methods:

constructor(s):

UniformModel(VectorFloat min, MatrixFloat max, MODE mode = DEF_MODE);

UniformModel(float min, float max, MODE mode = DEF_MODE);

set methods:

boolean setMin(const VectorFloat& min);

boolean setMin(float min);

boolean setMax(const MatrixFloat& max);

boolean setMax(float max);

get methods:

boolean getMin(const VectorFloat& min);

boolean getMax(const MatrixFloat& max);

interface contract for the StatisticalModelBase:

boolean assign(const StatisticalModelBase& arg);

boolean eq(const StatisticalModelBase& arg);

const String& className() const;

boolean init();

float getLikelihood(const VectorFloat& input);

float getLogLikelihood(const VectorFloat& input);

model reestimation methods:

double getOccupancy();

boolean setOccupancy(double arg);

boolean setAccessCount(long arg);

long getAccessCount();

boolean resetAccumulators();

boolean initialize(VectorFloat& param);

boolean accumulate(VectorFloat& param);

boolean accumulate(VectorFloat& param, VectorFloat& data, boolean precomp);

boolean update(VectorFloat& param);

private methods:

initialization methods:
```
float initScale();
```

examples:

This example shows how to construct a UniformModel and get likelihood of a vector:

// declare the UniformModel object
//
UniformModel model;

// set the compute mode
//
model.setMode(PRE_COMPUTE);

// set the minimum vector
//
VectorFloat min;
min.assign(L"-2, -1, -3");
model.setMin(min);

// set the maximum vector
//
VectorFloat max(L"1, 2, 0");
model.setMax(max);

// declare the input vector
//
VectorFloat input;
input.assign(L"-1.050, -7.709, -2.303");

// get the distance
//
Float distance = model.getLikelihood(input);

notes:

none