---

mtrx_except.hh

Go to the documentation of this file.

#ifndef _MTRX_EXCEPT_HH_
#define _MTRX_EXCEPT_HH_

#include <iostream>
#include "std_except.hh"

class MatrixException : public StandardException{
public:
  MatrixException() : StandardException() {};
  MatrixException(const string& fname, int ln, 
                  const string& msg = string())
    : StandardException(fname, ln, head()+msg) {}
  const char *head() const { return ""; }
};

class MatrixDimensionException : public MatrixException {
public:
  MatrixDimensionException() : MatrixException() {};
  MatrixDimensionException(const string& fname, int ln, 
                           const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Cannot allocate matrix:  Invalid dimension(s).";};
};

class MatrixMemoryExhaustException : public MatrixException {
public:
  MatrixMemoryExhaustException() : MatrixException() {};
  MatrixMemoryExhaustException(const string& fname, int ln, 
                               const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Cannot allocate matrix:  Memory full.";};
};

class MatrixEmptyMatrixException : public MatrixException {
public:
  MatrixEmptyMatrixException() : MatrixException() {};
  MatrixEmptyMatrixException(const string& fname, int ln, 
                             const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Illegal operation:  Matrix is empty.";};
};

class MatrixArrayBoundsException : public MatrixException {
public:
  MatrixArrayBoundsException() : MatrixException() {};
  MatrixArrayBoundsException(const string& fname, int ln, 
                             const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Index exceeds matrix dimensions.";};
};

class MatrixZeroIndexException : public MatrixException {
public:
  MatrixZeroIndexException() : MatrixException() {};
  MatrixZeroIndexException(const string& fname, int ln, 
                           const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Index into matrix is negative or zero.";};
};

class MatrixRowDimException : public MatrixException {
public:
  MatrixRowDimException() : MatrixException() {};
  MatrixRowDimException(const string& fname, int ln, 
                        const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Matrix row dimension mismatch.";};
};

class MatrixColDimException : public MatrixException {
public:
  MatrixColDimException() : MatrixException() {};
  MatrixColDimException(const string& fname, int ln, 
                        const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Matrix column dimension mismatch.";};
};

class MatrixBadArgException : public MatrixException {
public:
  MatrixBadArgException() : MatrixException() {};
  MatrixBadArgException(const string& fname, int ln, 
                        const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Invalid argument.";};
};

class MatrixIsComplexException : public MatrixException {
public:
  MatrixIsComplexException() : MatrixException() {};
  MatrixIsComplexException(const string& fname, int ln, 
                           const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Matrix operation not defined for complex matrices.";};
};

class MatrixDivisionByZeroException : public MatrixException {
public:
  MatrixDivisionByZeroException() : MatrixException() {};
  MatrixDivisionByZeroException(const string& fname, int ln, 
                                const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Division by zero.";};
};

class MatrixDomainException : public MatrixException {
public:
  MatrixDomainException() : MatrixException() {};
  MatrixDomainException(const string& fname, int ln, 
                        const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Matrix operation called with input not in required domain.";};
};

class MatrixRangeException : public MatrixException {
public:
  MatrixRangeException() : MatrixException() {};
  MatrixRangeException(const string& fname, int ln, 
                       const string& msg = string())
    : MatrixException(fname, ln, head()+msg) {}
  const char *head() const {return "Matrix operation yielded out-of-range result.";};
};


#endif

---