home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / c / cppmatrx.zip / MATRIX.ZIP / MATRIX.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-02  |  10.4 KB  |  444 lines
  1. #include <iostream.h>
  2. #include <stdarg.h>
  3. #include <math.h>
  4.  
  5.  
  6. typedef double matrix_t;
  7.  
  8.  
  9. class matrix {
  10.       matrix_t *matrix_data;
  11.       size_t matrix_size;
  12.  
  13.       public:
  14.          matrix (size_t matrix_length, ...);
  15.          matrix (char *dummy, size_t matrix_length,matrix_t fill_value=0.0);
  16.          matrix (matrix &m);
  17.          ~matrix (void) { delete matrix_data; }
  18.  
  19.          matrix_t get_elem (size_t row, size_t column) { return *(matrix_data + (row-1)*matrix_size + (column-1)); }
  20.          matrix_t put_elem (size_t row, size_t column, matrix_t elem) { return (*(matrix_data + (row-1)*matrix_size + (column-1)) = elem); }
  21.  
  22.          matrix_t* operator[] (size_t row) { return matrix_data + row*matrix_size; }
  23.          matrix_t& operator() (size_t row, size_t column) { return *(matrix_data + (row-1)*matrix_size + (column-1)); }
  24.          matrix operator= (matrix &m);
  25.          size_t get_matrix_size (void) { return matrix_size; }
  26.          int operator== (matrix m);
  27.          int operator!= (matrix m);
  28.          matrix operator+ (matrix m);
  29.          matrix operator- (matrix m);
  30.          matrix operator- (void);
  31.          friend matrix_t det (matrix m);
  32.          friend matrix_t cofactor (matrix m, size_t m_row, size_t m_column);
  33.          friend matrix minor (matrix m, size_t m_row, size_t m_column);
  34.          friend void transpose (matrix &m);
  35.          friend matrix operator* (matrix m, double r);
  36.          friend matrix operator* (double r, matrix m);
  37.          friend matrix operator* (matrix m, int r);
  38.          friend matrix operator* (int r, matrix m);
  39.          friend ostream& operator<< (ostream &s, matrix m);
  40.  
  41.          void print_matrix (void);
  42.    };
  43.  
  44. matrix::matrix (size_t matrix_length, ...)
  45. {
  46.    va_list argptr;
  47.    size_t elem_count;
  48.  
  49.    matrix_size = matrix_length;
  50.    matrix_data = new matrix_t [matrix_size*matrix_size];
  51.  
  52.    matrix_t *i;
  53.    size_t count;
  54.  
  55.    va_start (argptr, matrix_length);
  56.  
  57.    elem_count = matrix_size*matrix_size;
  58.  
  59.    for (i = matrix_data, count = 1; count <= elem_count; i++, count++)  {
  60.          *i = (matrix_t) (va_arg (argptr, matrix_t));
  61.       }
  62.  
  63.    va_end (argptr);
  64.  
  65.    cout << "\nCreated object Matrix\n";
  66. }
  67.  
  68. matrix::matrix (char *dummy, size_t matrix_length,matrix_t fill_value)
  69. {
  70.    size_t elem_count;
  71.  
  72.    matrix_size = matrix_length;
  73.    matrix_data = new matrix_t [matrix_size*matrix_size];
  74.  
  75.    matrix_t *i;
  76.    size_t count;
  77.  
  78.    elem_count = matrix_size*matrix_size;
  79.  
  80.    for (i = matrix_data, count = 1; count <= elem_count; count++, i++)
  81.       *i = (matrix_t) fill_value;
  82.  
  83.    cout << "\nCreated zero matrix.\n";
  84. }
  85.  
  86. #if 0
  87.  
  88. matrix::~matrix (void)
  89. {
  90.    delete matrix_data;
  91.  
  92.    // cout << "\nDeleted object Matrix\n";
  93. }
  94. #endif
  95.  
  96. #if 0
  97.  
  98. matrix_t matrix::get_elem (size_t row, size_t column)
  99. {
  100.    
  101. }
  102.  
  103. matrix_t matrix::put_elem (size_t row, size_t column, matrix_t elem)
  104. {
  105.  
  106. }
  107.  
  108. #endif
  109.  
  110. void matrix::print_matrix (void)
  111. {
  112.    matrix_t *i;
  113.    size_t row_count, column_count;
  114.  
  115.    cout << '\n';
  116.  
  117.    for (i = matrix_data, row_count = 0, column_count = 0; row_count < matrix_size; i++)   {
  118.          cout << *i << ' ';
  119.          if (column_count == (matrix_size - 1)) {
  120.                column_count = 0;
  121.                row_count++;
  122.                cout << '\n';
  123.             }
  124.                else
  125.                   column_count++;
  126.       }
  127. }
  128. #if 0
  129.  
  130. matrix_t* matrix::operator[] (size_t row)
  131. {
  132.    // return a reference to the first element in a given row
  133.  
  134. }
  135.  
  136. matrix_t& matrix::operator() (size_t row, size_t column)
  137. {
  138.  
  139. }
  140.  
  141. #endif
  142.  
  143. matrix::matrix (matrix &m)
  144. {
  145.    matrix_t *i, *j;
  146.    size_t count, elem_count;
  147.  
  148.    matrix_size = m.matrix_size;
  149.    elem_count = matrix_size*matrix_size;
  150.  
  151.    matrix_data = new matrix_t [elem_count];
  152.  
  153.    for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
  154.       *i = *j;
  155. }
  156.  
  157. matrix matrix::operator= (matrix &m)
  158. {
  159.  
  160.    size_t elem_count;
  161.    matrix_t *i, *j;
  162.  
  163.    size_t count;
  164.  
  165.    delete matrix_data;  // erase the current contents of the matrix on the left
  166.                         // side of the assignment
  167.  
  168.    matrix_size = m.matrix_size;
  169.    elem_count = matrix_size * matrix_size;
  170.  
  171.    matrix_data = new matrix_t [elem_count];  // allocate space for the new matrix, identical to the argument
  172.  
  173.    for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
  174.       *i = *j;
  175.  
  176.    return *this;
  177. }
  178.  
  179. matrix matrix::operator+ (matrix m)
  180. {
  181.    matrix temp ("*",matrix_size);
  182.    matrix_t *i, *j, *k;
  183.    size_t counter;
  184.    size_t elem_count;
  185.  
  186.    elem_count = matrix_size * matrix_size;
  187.  
  188.    for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
  189.         counter <= elem_count; i++, j++, k++, counter++)
  190.            *k = *i + *j;
  191.  
  192.    return temp;
  193. }
  194.  
  195. matrix matrix::operator- (matrix m)
  196. {
  197.    matrix temp ("*",matrix_size);
  198.    matrix_t *i, *j, *k;
  199.    size_t counter;
  200.    size_t elem_count;
  201.  
  202.    elem_count = matrix_size * matrix_size;
  203.  
  204.    for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
  205.         counter <= elem_count; i++, j++, k++, counter++)
  206.            *k = *i - *j;
  207.  
  208.    return temp;
  209. }
  210.  
  211.  
  212. inline void swap (matrix_t &a, matrix_t &b)
  213. {
  214.    matrix_t temp;
  215.  
  216.    temp = a;
  217.    a = b;
  218.    b = temp;
  219. }
  220.  
  221.  
  222. void transpose (matrix &m)
  223. {
  224.    size_t i,j;
  225.  
  226.    for (i = 2; i <= m.matrix_size; i++)
  227.       for (j = 1; j <= i-1; j++)
  228.          swap (m (i,j), m (j,i));
  229. }
  230.  
  231.  
  232. matrix minor (matrix m, size_t m_row, size_t m_column)
  233. {
  234.    matrix temp ("*", m.matrix_size-1);
  235.    size_t column, row;
  236.    size_t temp_column, temp_row;
  237.    
  238.    for (column = 1, temp_column = 1; column <= m.matrix_size; column++)  {
  239.          if (column != m_column) {
  240.                for (row = 1, temp_row = 1; row <= m.matrix_size; row++)
  241.                   if (row != m_row) {
  242.                      temp (temp_row, temp_column) = m (row, column);
  243.                      temp_row++;
  244.                   }
  245.  
  246.                temp_column++;
  247.             }
  248.       }
  249.  
  250.    return temp;
  251. }
  252.  
  253. #if 0
  254.  
  255. matrix_t det (matrix m)
  256. {
  257.  
  258.    int factor;
  259.  
  260.    if (m.matrix_size == 2)
  261.       return m (1,1)*m (2,2) - m (1,2)*m (2,1);
  262.          else  {
  263.                  matrix_t value = 0.0;
  264.                  size_t col;
  265.                  size_t temp_row, temp_col;
  266.                  size_t current_col;
  267.                  matrix temp ("*",m.matrix_size-1);
  268.  
  269.                  for (col = 1, factor = 1; col <= m.matrix_size; col++, factor *= (-1))   {
  270.                         for (current_col = 1, temp_col = 1; current_col <= m.matrix_size; current_col++)
  271.                            if (current_col != col)  {
  272.                               for (temp_row = 2; temp_row <= m.matrix_size; temp_row++)
  273.                                  temp (temp_row-1,temp_col) = m (temp_row,current_col);
  274.  
  275.                               temp_col++;
  276.                            }
  277.  
  278.                         value += m (1, col) * det (temp) * factor; 
  279.                     }
  280.  
  281.                  return value;
  282.             }
  283. }
  284.  
  285. #endif
  286.  
  287.  
  288. matrix_t det (matrix m)
  289. {
  290.    if (m.matrix_size == 2)
  291.       return m (1,1)*m (2,2) - m (1,2)*m (2,1);
  292.          else  {
  293.                  size_t i;
  294.                  matrix_t value = 0;
  295.  
  296.                  for (i = 1; i <= m.matrix_size; i++)
  297.                     value += m (1,i) * cofactor (m, 1, i);
  298.  
  299.                  return value;
  300.             }
  301. }
  302.  
  303.  
  304.  
  305. int matrix::operator== (matrix m)
  306. {
  307.  
  308.    if (matrix_size == m.matrix_size)
  309.       return ! memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
  310.          else
  311.             return 0;
  312. }
  313.  
  314.  
  315. int matrix::operator!= (matrix m)
  316. {
  317.  
  318.    if (matrix_size == m.matrix_size)
  319.       return memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
  320.          else
  321.             return 1;
  322. }
  323.  
  324. matrix operator* (matrix m, double r)
  325. {
  326.    matrix temp ("*",m.matrix_size);
  327.    matrix_t *i, *t;
  328.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  329.  
  330.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  331.       *t = *i * r;
  332.  
  333.    return temp;
  334. }
  335.  
  336. matrix operator* (double r, matrix m)
  337. {
  338.    matrix temp ("*",m.matrix_size);
  339.    matrix_t *i, *t;
  340.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  341.  
  342.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  343.       *t = *i * r;
  344.  
  345.    return temp;
  346. }
  347.  
  348. matrix operator* (matrix m, int r)
  349. {
  350.    matrix temp ("*",m.matrix_size);
  351.    matrix_t *i, *t;
  352.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  353.  
  354.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  355.       *t = *i * r;
  356.  
  357.    return temp;
  358. }
  359.  
  360. matrix operator* (int r, matrix m)
  361. {
  362.    matrix temp ("*",m.matrix_size);
  363.    matrix_t *i, *t;
  364.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  365.  
  366.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  367.       *t = *i * r;
  368.  
  369.    return temp;
  370. }
  371.  
  372. matrix_t cofactor (matrix m, size_t m_row, size_t m_column)
  373. {
  374.    int factor;
  375.  
  376.    if ((m_row+m_column) % 2)
  377.       factor = (-1);
  378.          else
  379.             factor = 1;
  380.  
  381.    return (matrix_t) factor * det (minor (m, m_row, m_column));
  382. }
  383.  
  384.  
  385. matrix matrix::operator- (void)
  386. {
  387.    matrix temp ("*",matrix_size);
  388.    matrix_t *i, *t;
  389.    size_t count, elem_count = matrix_size*matrix_size;
  390.  
  391.    for (i = matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  392.       *t = -*i;
  393.  
  394.    return temp;
  395. }
  396.  
  397. ostream& operator<< (ostream &s, matrix m)
  398. {
  399.    size_t i,j;
  400.  
  401.    s << '\n';
  402.  
  403.    for (i = 1; i <= m.matrix_size; i++)   {
  404.          for (j = 1; j <= m.matrix_size; j++)
  405.             s << m (i,j) << ' ';
  406.  
  407.          s << '\n';
  408.       }
  409.  
  410.    return s;
  411. }
  412.  
  413. main (void)
  414. {
  415.    matrix matrix_a (3,1.0,2.0,3.0,
  416.                       4.0,5.0,6.0,
  417.                       7.0,7.0,7.0);
  418.  
  419.    matrix matrix_b (3,1.0,1.0,3.0,
  420.                       4.0,5.0,6.0,
  421.                       7.0,8.0,9.0);
  422.  
  423.    matrix matrix_c ("*",3);
  424.  
  425.    matrix matrix_test (4, 2.0,  9.0,  9.0,  4.0,
  426.                           2.0, -3.0, 12.0,  8.0,
  427.                           4.0,  8.0,  3.0, -5.0,
  428.                           1.0,  2.0,  6.0,  4.0);
  429.  
  430.    matrix matrix_minor (3, 2.0,9.0,4.0,
  431.                            4.0,8.0,-5.0,
  432.                            1.0,2.0,4.0);
  433.  
  434.  
  435.    cout << "\nTesting the output operator.\n";
  436.  
  437.    cout << '\n';
  438.    cout << matrix_test;
  439.    cout << '\n';
  440.  
  441.    return 0;
  442. }
  443.  
  444.