lab 3 start

Lab3/matrix.h

@@ -0,0 +1,103 @@
+#ifndef matrix_h
+#define matrix_h
+ 
+#include <iostream> 
+#include "row.h"
+class Matrix
+{
+	public:
+		// No default (no argument) constructor.  It doesn't really make
+		// sense to have one as we cannot rely on a size.  This may trip
+		// us up later, but it will lead to a better implementation.
+		// matrix();
+ 
+		// Constructor - create Matrix and clear cells.  If rows or
+		// cols is < 1, throw an exception
+		Matrix(unsigned int rows, unsigned int cols);
+ 
+		// Copy constructor - make a new Matrix just like rhs
+		Matrix(const Matrix& from);
+ 
+		// Destructor.  Free allocated memory
+		~Matrix();
+ 
+		// Assignment operator - make this just like rhs.  Must function
+        	// correctly even if rhs is a different size than this.
+		Matrix& operator=(const Matrix& rhs);
+ 
+		// Named Constructor - produce a square identity matrix of the
+		// requested size.  Since we do not know how the object produced will
+		// be used, we pretty much have to return by value.  A size of 0 
+		// would not make sense and should throw an exception.
+		static Matrix identity(unsigned int size);
+ 
+		// Matrix addition - lhs and rhs must be same size otherwise
+		// an exception shall be thrown
+		Matrix operator+(const Matrix& rhs) const;
+ 
+		// Matrix multiplication - lhs and rhs must be compatible 
+		// otherwise an exception shall be thrown
+		Matrix operator*(const Matrix& rhs) const;
+ 
+		// Scalar multiplication.  Note, this function will support
+		// someMatrixObject * 5.0, but not 5.0 * someMatrixObject.
+		Matrix operator*(const double scale) const;
+
+		// Transpose of a Matrix - should always work, hence no exception
+		Matrix operator~() const;
+ 
+		// Clear Matrix to all members 0.0
+		void clear();
+  
+		// Access Operators - throw an exception if index out of range
+		Row& operator[](unsigned int row);
+ 
+		// const version of above - throws an exception if indices are out of
+		// range
+		const Row& operator[](unsigned int row) const;
+ 
+		// I/O - for convenience - this is intended to be called by the global
+		// << operator declared below.
+		void out(std::ostream& os) const;
+		
+	private:
+		// An array of Row pointers size "rows" that each point to a double array
+		// of size "cols"
+		Row** the_matrix;
+		unsigned int rows;
+		unsigned int cols;
+
+		/** routines **/
+
+		// add any "helper" routine here, such as routines to support
+		// matrix inversion
+
+};
+
+/** Some Related Global Functions **/
+ 
+// Overloaded global << with std::ostream as lhs, Matrix as rhs.  This method
+// should generate output compatible with an ostream which is commonly used
+// with console (cout) and files.  Something like:
+// [[ r0c0, r0c1, r0c2 ]
+//  [ r1c0, r1c1, r1c2 ]
+//  [ r0c0, r0c1, r0c2 ]]
+// would be appropriate.
+//
+// Since this is a global function, it does not have access to the private
+// data of a Matrix object.  So, it will need to use the public interface of
+// Matrix to do its job.  The method Matrix::out was added to Matrix
+// specifically for this purpose.  The other option would have been to make
+// it a "friend"
+std::ostream& operator<<(std::ostream& os, const Matrix& rhs);
+ 
+// We would normally have a corresponding >> operator, but
+// will defer that exercise that until a later assignment.
+
+
+// Scalar multiplication with a global function.  Note, this function will
+// support 5.0 * someMatrixObject, but not someMatrixObject * 5.0
+Matrix operator*(const double scale, const Matrix& rhs);
+
+#endif
+// Based on lab by Dr. Darrin Rothe ((c) 2015 Dr. Darrin Rothe)