// ННГУ, ВМК, Курс "Методы программирования-2", С++, ООП
//
// utmatr4.h - Copyright (c) Гергель В.П. 07.05.2001
//
// Верхние треугольные матрицы - реализация на основе шаблона вектора

#ifndef __TMATRIX_H
#define __TMATRIX_H

#include <conio.h>
#include <iomanip.h>
#include <iostream.h>

template <class ValType>
  class TVector {
    protected:
      ValType *pVector;
      int Size;       // размер вектора
      int StartIndex; // индекс первого элемента вектора
    public:
      TVector(int s=10, int si=0 );               //                         (#О1)
      TVector(const TVector &v);                  // конструктор копирования (#Л1)
     ~TVector();                                  //                         (#О2)
      int GetSize()        { return Size;       } // размер вектора          (#О)
      int GetStartIndex()  { return StartIndex; } // индекс первого элемента (#О)
      ValType & GetValue   (int pos);             // доступ с контролем индекса(#П1)
      ValType & operator[] (int pos);             // доступ                  (#П2)
      int        operator==(const TVector &v);    // сравнение               (#П3)
      TVector  & operator= (const TVector &v);    // присванивание           (#О3)
      // скалярные операции
      TVector    operator+ (const ValType &val);  // прибавить скаляр        (#Л2)
      TVector    operator- (const ValType &val);  // вычесть скаляр          (#С1)
      TVector    operator* (const ValType &val);  // умножить на скаляр      (#С2)
      // векторные операции
      TVector    operator+ (const TVector &v);    // сложение                (#С3)
      TVector    operator- (const TVector &v);    // вычитание               (#С4)
      TVector    operator* (const TVector &v);    // скалярное произведение  (#С5)
      // ввод-вывод
      friend istream & operator>>( istream &in, TVector &v) {              //(#П4)


Skipped...

      }
      friend ostream & operator<<( ostream &out, const TVector &v) {       //(#С6)


Skipped...

      }
};

template <class ValType>
TVector<ValType>::TVector (int s, int si ) {
  pVector = new ValType[s];
  Size = s; StartIndex = si;
}

template <class ValType>
TVector<ValType>::TVector(const TVector<ValType> &v) { //конструктор копирования


Skipped...

}

template <class ValType>
TVector<ValType>::~TVector () {
  delete[] pVector;
}

template <class ValType>
ValType & TVector<ValType>::operator[] (int pos) { // доступ без конроля индекса


Skipped...

}

template <class ValType>
TVector<ValType> & TVector<ValType>::operator=(const TVector &v){ // присваивание
  if ( this != &v ) {
    if ( Size != v.Size ) {
      delete[] pVector;
      pVector = new ValType[v.Size];
    }
    Size = v.Size; StartIndex = v.StartIndex;
    for ( int i=0; i <Size; i++ ) pVector[i] = v.pVector[i];
  }
  return *this;
}

template <class ValType>
TVector<ValType> TVector<ValType>::operator+(const TVector<ValType> &v) { // сложение


Skipped...

}

// Верхние треугольные матрицы

template <class ValType>
  class TMatrix : public TVector<TVector<ValType> > {
    public:
      TMatrix(int s=10);                              //                     (#О1)
      TMatrix(const TMatrix &mt);                     // копирование         (#Л1)
      TMatrix(const TVector<TVector<ValType> > &mt);  // преобразование типа (#Л2)
      TMatrix & operator==(const TMatrix &mt);        // сравнение           (#П1)
      TMatrix & operator= (const TMatrix &mt);        // присваивание        (#О2)
      TMatrix   operator+ (const TMatrix &mt);        // сложение            (#П2)
      TMatrix   operator- (const TMatrix &mt);        // вычитание           (#С1)
      TMatrix   operator* (const TMatrix &mt);        // умножение           (#С2)
      // ввод / вывод
      friend istream & operator>>( istream &in, TMatrix &mt) {             //(#П3)


Skipped...

        return in;
      }
      friend ostream & operator<<( ostream &out, const TMatrix &mt) {      //(#С3)


Skipped...

        return out;
      }
};

template <class ValType>                //
TMatrix<ValType> :: TMatrix ( int s ) : TVector<TVector<ValType> >(s) {
  for ( int i=0; i <s; i++ )
    pVector[i] = TVector<ValType>(s-i,i);
}

template <class ValType>                // конструктор копирования
TMatrix<ValType> :: TMatrix ( const TMatrix<ValType> &mt ) :


Skipped...


template <class ValType>                // конструктор преобразования типа
TMatrix<ValType> :: TMatrix ( const TVector<TVector<ValType> > &mt ) :


Skipped...


template <class ValType>                // присваивание
TMatrix<ValType> & TMatrix<ValType>::operator=(const TMatrix<ValType> &mt){
  if ( this != &mt ) {
    if ( Size != mt.Size ) {
      delete[] pVector;
      pVector = new TVector<ValType>[mt.Size];
    }
    Size = mt.Size; StartIndex = mt.StartIndex;
    for ( int i=0; i <Size; i++ ) pVector[i] = mt.pVector[i];
  }
  return *this;
}

template <class ValType>                // сложение
TMatrix<ValType> TMatrix<ValType>::operator+(const TMatrix<ValType> &mt) {


Skipped...

}
// TVector О3 Л2 П4 С6
// TMatrix О2 Л2 П3 С3
#endif