name: MatrixComplexLong : public MMatrix<ComplexLong, complexlong>

synopsis:

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

#include <MatrixComplexLong.h>

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

quick start:

MatrixComplexLong val0(2, 3, L"1-6j, 2+5j, -3+4j,
                               -4-4j, -5-8j, 6-4j");

MatrixComplexLong val1(3, 3, L"1-6j, 2+5j, -3+4j,
                               -4-4j, -5-8j, 6-4j", Integral::LOWER_TRIANGULAR);

description:

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

error codes:

error code indicating MatrixComplexLong class general error:
```
static const long ERR = 25200;
```

protected data:

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

required public methods:

static methods:

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/constructors:

~MatrixComplexLong();

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

MatrixComplexLong(const MatrixComplexLong& matrix);

assign methods:

these methods are inherited from the MMatrix template class

operator= methods:

MatrixComplexLong& operator=(const MatrixComplexLong& 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

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

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

private methods:

none

examples:

This example demonstrates basic linear algebra operations using the matrix class:

#include <MatrixComplexLong.h>
#include <VectorComplexLong.h>

// this example performs a basic operation with an integer complex matrix
//
int main() {

  // define the complex matrix A, complex vector b
  // and the resulting complex vector x
  //
  MatrixComplexLong A(3, 3, L"1, 2j, -9j,
                              -7, 0, 6+8j,
                               1, 1, 1+1j", Integral::FULL);
  A.debug(L"matrix A");

  // get the max element
  //
  ComplexLong max;
  max = A.max();
  max.debug(L"max(A)");

  // compute the determinant
  //
  ComplexLong det;
  det = A.determinant();
  det.debug(L"det(A)");
    
  // multiply matrix by b, put the result into x
  //
  VectorComplexLong b(L"-3-3j, -5+1j, 1+3j");
  b.debug(L"vector b");

  VectorComplexLong x;
  A.multv(x, b);
  x.debug(L"Ab");
  
  // multiply matrix by diagonal matrix
  //
  MatrixComplexLong B(3, 3, L"1j, 1j, 1j", Integral::DIAGONAL);
  B.debug(L"matrix B");
  A.mult(B);
  A.debug(L"AB");

  return true;
}

notes:

See the notes section of MMatrix.