/********************************************************************
  Engineering 3891 Advanced Structured Programming
  Assignment: 7  Date Due: November 22nd/2000
  Name: Daryl Martin
  Student #: 9713520
  Username: darylm
*********************************************************************/

#include "assign7.h"

int Vector::count = 0;

/******************************************************************
 * Vector::Vector(int s) --  constructor, nonpos error if s<1 and 
 *	nomem error if s is not < 1.
 *
 *
 *										Date:  11/24/00
 *******************************************************************/

Vector::Vector(int s){
	if (s < 0) {
		vError(NONPOS);
		p = 0;
		size = 0;
		count++;
	}
	else {
		count++;
		if((p=new double[s])) size = s;
		
		else {
			size = 0;
			vError(NOMEM);
		}
	}

}


/******************************************************************
 * Vector::ub() const --  Passes back the last index
 *
 *
 *										Date:  11/24/00
 *******************************************************************/
int Vector::ub() const{
	
	return size - 1;

}

/******************************************************************
 * Vector::howMany() const --  Passes back the count
 *
 *
 *										Date:  11/24/00
 *******************************************************************/

int Vector::howMany() const{

	return count;

}

static double dummy;

/******************************************************************
 * Vector::operator[](int i) --  Error if i is not in range. If 
 *	i is out of range, operator[] will return a reference to a 
 *	single safe location
 *
 *
 *										Date:  11/24/00
 *******************************************************************/

double& Vector::operator[](int i){
	if (i<0 || i>(size-1)){
		vError(OUTRANGE);
		return dummy;
	}
	else{
	return p[i];
	}
}


/******************************************************************
 * Vector::operator+(const Vector& rhs) --  NOT an error if sizes 
 *	are different if v longer, add 1st size components of v if v 
 *	shorter, add to only 1st v.size components outrange is error
 *
 *
 *										Date:  11/24/00
 *******************************************************************/

Vector Vector::operator+(const Vector& rhs){
	Vector result(size < rhs.size ? rhs.size : size);
	if(result.size > 0) {
		if(size == rhs.size) {
		for(int i = 0; i < size; i++) {
				result[i] = p[i] + rhs.p[i];
			}
		} else if(size < rhs.size) {
			for(int i = 0; i < size; i++) {
				result[i] = p[i] + rhs.p[i];
			}
			for(int j = size; j < rhs.size; j++) {
				result[j] = rhs.p[j];
			}
		} else { 
			for(int i = 0; i < rhs.size; i++) {
				result[i] = p[i] + rhs.p[i];
			}
			for(int j = rhs.size; j < size; j++) {
				result[j] = p[j];
			}
		}
	}
	return result;
}


/******************************************************************
 * Vector::Vector(const Vector& orig) --  A copy constructor 
 *
 
 *
 *										Date:  11/24/00
 *******************************************************************/

Vector::Vector(const Vector& orig){
	count++;

	if (size != orig.size){
		if (p = new double [orig.size]){
			size = orig.size;
		} else {
			size = 0;
			vError(NOMEM);
		}
	}
	for(int i=0; i<size; i++) {
		p[i] = orig.p[i];
	}
}

/******************************************************************
 * Vector::operator=(const Vector& rhs) --  Assignment Overload
 *
 
 *
 *										Date:  11/24/00
 *******************************************************************/

Vector& Vector::operator=(const Vector& rhs){
	if (size != rhs.size){
		delete []p;
		if (p = new double[rhs.size]){
			size = rhs.size;
		}
		else size = 0;
	}
	for(int i=0; i < size; i++){
		p[i] = rhs.p[i];
	}
	return *this;

}

/******************************************************************
 * Vector::Vector --  A Destructor
 *
 *
 *										Date:  11/24/00
 *******************************************************************/

Vector::~Vector(){
	delete [] p;
	count--;
}