name: Mel

synopsis:

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

#include <Mel.h>

boolean compute(VectorFloat& mel, const VectorFloat& freq);

quick start:

VectorFloat freq(1);
VectorFloat mel;

freq(0) = 1000;
Mel::compute(mel, freq);

description:

The Mel class implements a function that is commonly used to map frequency in Hz to a scale that is more perceptually-meaningful. The units of this scale are referred to as mel (short for melody), a unit used to measure pitch. The approximation for the Mel scale that is implemented in this class is given by:

  Mel = 2595 log10 (1 + freq / 700.0)

For more details about this transformation, see:

J. Picone,

"Signal Modeling Techniques in Speech Recognition,"

IEEE Proceedings

See the Bark class for an alternate way to approximate this scale.

dependencies:

public constants:

define the class name:

static const String CLASS_NAME = L"Mel";

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

error codes:

error code indicating Mel class general error:
```
static const long ERR = (long)35400;
```

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):
```
~Mel();
```
```
Mel();
```
```
Mel(const Mel& arg);
```
assign methods:
```
boolean assign(const Mel& arg)
```
operator= methods:
```
Mel& operator= (const Mel& 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 Mel& 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& mel, float freq);

static boolean compute(VectorFloat& mel, const VectorFloat& freq);

private methods:

none.

examples:

This example shows how to perform a Mel transformation of an input vector:

#include <Mel.h>
#include <VectorFloat.h>

int main() {

  // declare a Mel object
  //
  Mel ml;

  // declare the input and output vectors
  //
  VectorFloat freq(L"100, 200, 300, 400, 500, 600");
  VectorFloat mel;

  // transform the input using the Mel scale
  //
  Mel::compute(mel, freq);

  // 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).