name: Chebyshev

synopsis:

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

#include <Chebyshev.h>

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

quick start:

float output;
Chebyshev::compute(output, 1.0);
Chebyshev::compute(output, 1.0, 2);

description:

The Chebyshev class implements a family of Chebyshev functions. For more details about this implementation, see:

Digital Signal Processing

An lth order Chebyshev function is defined by: power series:

This is implemented in terms of hyperbolic functions defined in the system library class Integral.

dependencies:

public constants:

define the class name:

static const String CLASS_NAME = L"Chebyshev";

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

define default values and arguments: DEF_ORDER represents the default Chebyshev function order to be used by the compute method.

static const long DEF_ORDER = 1;

error codes:

error code indicating Chebyshev class general error:
```
static const long ERR = (long)035500;
```

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):

~Chebyshev();

Chebyshev();

Chebyshev(const Chebyshev& arg);

assign methods:
```
boolean assign(const Chebyshev& arg)
```

operator= methods:

Chebyshev& operator= (const Chebyshev& 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 Chebyshev& 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);

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

private methods:

none.

examples:

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

#include <Chebyshev.h>

int main() {

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

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

  // compute a value using a specific order
  //
  input = 0.5;
  Chebyshev::compute(output, input, 2);

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

notes:

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