name: MatrixUllong : public MMatrix<Ullong, ullong>

synopsis:

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

#include <MatrixUllong.h>

MatrixUllong(long nrows = DEF_SIZE, long ncols = DEF_SIZE,
             long type = DEF_TYPE);
MatrixUllong(const MatrixUllong& matrix);

quick start:

ullong data0[6] = {1, 2, 3, 4, 5, 6};
ullong data1[6] = {4, 6, 7, 2, 3, 9};

MatrixUllong val0;
MatrixUllong val1(3, 3, Integral::LOWER_TRIANGLE);
val0.assign(2, 3, data0);
val0.assign(3, 3, data1);

description:

The MatrixUllong class manages a matrix of Ullong objects. It is derived from the MMatrix class and inherits the commonly used mathematical, logical, linear algebra and i/o methods from it. A MatrixUllong 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:

MMatrix

public constants:

define the class name:

static const String CLASS_NAME = L"MatrixUllong";

error codes:

error code indicating MatrixUllong class general error:
```
static const long ERR = 24400;
```

protected data:

define memory manager:
```
static MemoryManager mgr_d;
```

required public methods:

static methods:

inline static const String& name();

static boolean diagnose(Integral::DEBUG debug_level);

debug methods: the setDebug() method is inherited from the MMatrix template class
```
boolean debug(const unichar* message) const;
```

destructor/constructor(s):

~MatrixUllong();

MatrixUllong(long nrows = DEF_SIZE, long ncols = DEF_SIZE, long type = DEF_TYPE);

MatrixUllong(const MatrixUllong& matrix);

assign methods:

these methods are inherited from the MMatrix template class

operator= methods:

MatrixUllong& operator=(const MatrixUllong& matrix);

i/o methods: the sofSize, readData and writeData methods are inherited from the MMatrix 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;

equality methods:

these methods are inherited from the MMatrix template class

memory management methods: the clear method is inherited from the MMatrix template class

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

class-specific public methods:

constructor: this method constructs a matrix with a unichar* object

MatrixUllong(long nrows, long ncols, const unichar* arg, long type = DEF_TYPE, const Char delim = DEF_DELIM);

operator= methods: this method assigns a ullong value to the matrix
```
MatrixUllong& operator= (ullong value);
```

private methods:

none

examples:

This example shows how to write a MatrixUllong object into a Sof file

// define a MatrixUllong object
//
MatrixUllong val0(3, 3, Integral::SYMMETRIC);

// assign values to the matrix by calling operator= method
//
val0 = 5;

// define a file name and declare an Sof object
//       
String tmp_filename(L"foo");
Sof tmp_file;

// open the file in write mode       
//       
tmp_file.open(tmp_filename, File::WRITE_ONLY, File::TEXT);

// write the matrix object to the Sof file
//       
val0.write(tmp_file, (long)0);

// close the file
//       
tmp_file.close();

notes:

See the notes section of MMatrix.