/********************************************************************
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--;
}