name: Bessel

synopsis:

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

#include <Bessel.h>

boolean compute(float& output, float input, long order, long nterms);

quick start:

float output;
Bessel::compute(output, 1.0);
Bessel::compute(output, 1.0, 0, 20);

description:

The Bessel class implements a family of Bessel functions using an infinite series approximation. For more details about this implementation, see:

Digital Signal Processing

Currently, only a zeroth order Bessel function, which is the most common order for signal processing applications, is implemented. A zeroth order Bessel function can be approximated by the following power series:

Normally, 20 terms in the summation provide an acceptable level of accuracy. This limit can be specified in the compute method.

dependencies:

public constants:

define the class name:

static const String CLASS_NAME = L"Bessel";

define i/o related constants:
```
static const String DEF_PARAM = L"";
```

define default values and arguments: DEF_ORDER represents the default Bessel function order to be used by the compute method; DEF_NTERMS represents how many terms are used in the approximation.

static const long DEF_ORDER = 0;

static const long DEF_NTERMS = 20;

error codes:

error code indicating Bessel class general error:

static const long ERR = (long)35500;

static const long ERR_UNSUPA = (long)35501;

protected data:

debug level:
```
static Integral::DEBUG debug_level_d;
```
a static 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 setDebug(Integral::DEBUG debug_level);

boolean debug(const unichar* message) const;

destructor/constructor(s):

~Bessel();

Bessel();

Bessel(const Bessel& arg);

assign methods:
```
boolean assign(const Bessel& arg)
```
operator= methods:
```
Bessel& operator= (const Bessel& 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 = DEF_PARAM,long size = SofParser::FULL_OBJECT, boolean param = true, boolean nested = false);

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

equality methods:
```
boolean eq(const Bessel& 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 ctype = Integral::DEF_CMODE);

class-specific public methods:

computational methods:

static boolean compute(float& output, float input, long order=DEF_ORDER, long nterms=DEF_NTERMS);

static boolean compute(VectorFloat& output, const VectorFloat& input, long order=DEF_ORDER, long nterms=DEF_NTERMS);

private methods:

none.

examples:

This example shows how to compute a value using a Bessel function:

#include <Bessel.h>

int main() {

  // declare variables for the input and output
  //
  float input;
  float output;

  // compute a value using the defaults
  //
  input = 1.0;
  Bessel::compute(output, input);

  // compute a value using a specific order and power series length
  //
  input = 0.5;
  Bessel::compute(output, input, 0, 27);

  // exit gracefully
  //
  Integral::exit();
}

notes:

Currently, only a zeroth order function is supported.
This class has no internal data, so its compute function can be invoked as a static function call (the class need not be instantiated).