name: Float: public MScalar<float, float32>

synopsis:

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

#include <Float.h>

Float(float arg = DEF_VALUE);
Float(const Float& arg);

quick start:

Float val0;
val0 = 10.0;

Float val1(5.0);
Float val2;

val2 = val0.exp10(2.0) + val1.pow(3.0);

description:

The Float class manages 32-bit float numbers. It is derived from the MScalar class and inherits commonly-used mathematical, logical, DSP and i/o methods from it. A Float object can read itself from (or write itself to) a Sof file. It includes the memory management methods which use the MemoryManager class to allocate or delete memory from the heap.

dependencies:

MScalar

public constants:

define the class name:

static const String CLASS_NAME = L"Float";

error codes:

error code indicating Float class general error:
```
static const long ERR = 21000;
```

protected data:

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:

setDebug is inherited from the MScalar template class

boolean debug(const unichar* message) const;

destructor/constructor(s):

~Float();

Float(float arg = DEF_VALUE);

Float(const Float& arg);

assign methods:

assign methods are inherited from the MScalar template class

operator= methods:
```
Float& operator= (const Float& arg);
```

i/o methods:

the sofSize method is inherited from the MScalar template class

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

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

readData and writeData are inherited from the MScalar template class

equality methods:

equality methods are inherited from the MScalar template class

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

clear is inherited from the MScalar template class

class-specific public methods:

operator overload methods:
```
Float& operator= (float arg);
```

private methods:

bitwise methods: declare these as private member functions because they are not defined for floating point operations

float bor(float, float);

float band(float, float);

float bxor(float, float);

float brs(float, float);

float bls(float, float);

float bcmpl(float);

modulus methods: declare these as private member functions because they are not defined for floating point operations
```
float mod(float, float);
```
```
float& operator%= (float);
```
```
float& operator% (float);
```

examples:

This example shows how to write a Float object into a Sof file:

Float val0(5.0);
String tmp_filename(L"foo");
Sof tmp_file;
tmp_file.open(tmp_filename, File::WRITE_ONLY, File::TEXT);
       
val0.write(tmp_file, (long)0);
tmp_file.close();

This example shows how to generate a random number:

Float rand_num;
float value;
float value1;
       
// using default seed
//
value = rand_num.randSeed();
     
// Gaussian random number generation
//
float mean = 5.0;
float std_dev = 3.0;
value1 = rand_num.grand(mean, std_dev);

notes:

See the notes section of MScalar.
The Float class defines the bor, band, bxor, brs, bls, bcmpl, mod, operator%= and operator% integer methods as private to block the templatized functions in MScalar. So if a user attempts to use Float::mod() they will get a compilation error rather than a runtime error.