Array::Array(const Array &arrayToCopy)
:size(arrayToCopy.size)
{
    size = arrayToCopy.getSize();
    ptr = new double[size];
    for( int i = 0; i<size;i++)
    {
        ptr[i] = arrayToCopy[i];
    }
}

#ifndef ARRAY2D_H
#define ARRAY2D_H

#include <iostream>
using std::ostream;
using std::istream;

class Array2D
{
    friend ostream &operator<<( ostream & , const Array &);
    friend istream &operator>>( istream &, Array &);
public:
    Array2D(int,int);
    Array2D( const Array2D &);
    ~Array2D();
    int getSize() const;

    const Array2D &operator = (const Array2D &);
    bool operator ==(const Array2D &) const;

    bool operator!=(const Array2D &right) const
    {
        return!(*this == right);
    }

    double operator() (double,double);

    double &operator() (double, double) const;
private:
     int size;
     double *ptr;
     int row;
     int column;
};

#include <iostream>
using std::cerr;
using std::cout;
using std::cin;
using std::endl;

#include <iomanip>
using std::setw;

#include <cstdlib>
using std::exit;

#include "Array2D.h"

Array2D::Array2D(int rows, int columns)
{
    row = rows;
    column = colmns;
    size = rows * columns;
    ptr = new double[size];

    for(int i = 0; i<size; i++)
    {
        ptr[i] = 0;
    }
}

Array2D::~Array2D()
{
    delete [] ptr;
}

int Array2D::getSize() const
{
    return size;
}


Array2D::Array2D(const Array2D &arrayToCopy)
:size(arrayToCopy.size)
{
    size = arrayToCopy.getSize();
    ptr = new double[size];
    for( int i = 0; i<row;i++)
    {
        for(int j = 0; j<column;j++)
        {
          ptr[i] = arrayToCopy[i];
        }
    }
}


double Array2D::operator()(int row1, int col1)
{
    int index;
    index = column *row1 + col1;
    return ptr[index];
}

double &Array2D :: operator()(int row2, int col2)
{
    int index;
    index = (columns *row2) + col2;
    return ptr[index];
}

const Array2D &Array2D::operator=( const Array2D &right)
{
    if( &right != this)
    {
        delete [] ptr;
        size = row*column;
        ptr = new double[ size];
        row = right.row;
        col = right.column;
    }
    for( int i = 0; i <size; i++)
    {
        ptr[i] = right.ptr[i];
    }
    return *this;
}

bool Array2D::operator==( const Array2D &right) const
{
    if( row != right.row)
        return false;
    else if(col!= right.col)
        return false;

    for( int i = 0; i< size; i++)
        if(ptr[ i] ! = right.ptr[ i])
            return false;

    return true;
}

istream &operator>>(istream &input , Array &a)
{
    for(int i = 0; i <a.size; i++)
    {
        input a.ptr[i];
    }
    return input;
}

ostream &operator<<(ostream &output, const Array &a)
{
    for(int i = 0; i <a.size;i++)
    {
        output<<a.ptr[i];
    }
    return output;
}