На главную
Сервис "Обмен садиками" - бесплатный инструмент поиска обмена местами в дошкольных образовательных учреждениях (ДОУ) между детьми одного возраста
Rambler's Top100   Mini-Soft Soft Исходники Лабораторные # 1,2,3,4
Разделы сайта:
Образование
Курсовые
Дипломы
Рефераты
Словари
БЭМТ
БФ НГТУ
Программы
Soft
Исходники
Статьи
MSDN
Библиотека
Инфо
Ссылки
Гостевая книга
Поиск по сайту:
Добавить работу на сайт
Ваше образование
Два высших
Неполное среднее
Среднее
Средне-специальное
Неполное высшее
Высшее
Новые поступления:
Анализ и оценка эффективности использования оборотных активов организации 2011-10-11
Товарные биржи и их значение в коммерческой деятельности торговых предприятий 2011-10-11
Контрольная по ботанике 2011-09-04
Контрольная работа по ботанике 2011-09-04
RSS Все новинки...


Проверить аттестат

Мы принимаем Яндекс.Деньги
Смотри также Смотри также:
Форматирование текстового файла - курсовой проект
Хранение текста в двоичном файле - курсовой проект
Иерархические структуры данных в памяти - курсовой проект
Курсовая работа по программированию на VB
Учебник по VBA
MSDN на русском языке
 

Лабораторные # 1,2,3,4


Автор: Горбунов Александр

Скачать архив: laba10961.zip (1.3 Mб)
Выполнено в Borland Builder 6. Сдавалось Романову Е.Л., где сдавалась: БФ НГТУ, когда сдавался: 2007, оценка: 5

//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "CSPIN"
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
   : TForm(Owner)
{
}
    
template class vector
   {
   T *dt;
   int n, sz;
   public:
   vector()
      {
      n = 0;
      dt = new T[10];
      sz = 10;
      }
   void Extend()
      {
      if (n != sz-1) return;
      sz *= 2;
      T *q = new T[sz];
      for (int i=0; i
         q[i] = dt[i];
      delete dt;
      dt = q;
      }
   void InsSort(T in)
      {
      int i, j;
      Extend();
      if (n == 0)
         {
         dt[n++] = in;
         return;
         };
      for (i=0; i
      for (j=n; j>i; j--)
         dt[j] = dt[j-1];
      dt[j] = in;
      n++;
      };
   void Add(T in)
      {
      Extend();
      dt[n] = in;
      n++;
      };
   void rez()
      {
      if (!n)
         {
         Form1->BitBtn23->Enabled = False;
         Form1->BitBtn24->Enabled = False;
         Form1->CSpinEdit1->Enabled = False;
         }
      else
         {
         Form1->BitBtn23->Enabled = True;
         Form1->BitBtn24->Enabled = True;
         Form1->CSpinEdit1->Enabled = True;
         }
      Form1->CSpinEdit1->MinValue = 1;
      Form1->CSpinEdit1->MaxValue = n;
      if (n == 1)
         {
         Form1->CSpinEdit1->Value = 1;
         Form1->CSpinEdit1->ReadOnly = True;
         }
      else
         Form1->CSpinEdit1->ReadOnly = False;
      }
   void rem(int k)
      {
      for (; k
         dt[k] = dt[k+1];
      n--;
      }
   T & operator[](int k)
      {
      return dt[k];
      };
};
//---------------------------------------------------------------------------
class Matx
{
   int size;                               // Размерность матрицы
   int **X;                                 // ДМУ на стрки матрицы
   public:
   Matx(Matx &S)                            // Конструктор (копирование)
      {
      size = S.size;
      X = new int * [size];
      for(int i=0; i
         {
         X[i] = new int [size];
         for(int j=0; j
         };
//      ShowMessage("Конструктор Matx(Matx &S) создал матрицу по адресу " + IntToHex((int)this, 8));
      };
   Matx(int n_size)                           // Коструктор (по размеру)
      {
      size = n_size;
      X = new int * [size];
      for(int i=0; i
         {
         X[i] = new int [size];
         for(int j=0; j
         }
//      ShowMessage("Конструктор Matx(int n_size) создал матрицу по адресу " + IntToHex((int)this, 8));
      };
   Matx()                                  // Коструктор (без параметров)
      {
      size = 1;
      X = new int * [size];
      for(int i=0; i
         {
         X[i] = new int [size];
         for(int j=0; j
         }
//      ShowMessage("Конструктор Matx() создал матрицу по адресу " + IntToHex((int)this, 8));
      };
   void Print(TStringGrid *Out)                  // Вывести данные в таблицу
      {
      Out->ColCount = size;
      Out->RowCount = size;
      for(int i=0; i
         for(int j=0; jCells[i][j] = IntToStr(X[i][j]);
      };
   void FillRand()                            // Заполнить случайно
      {
      for(int i=0; i
         for(int j=0; j
            X[i][j] = random(100);
      };
   void FillSort()                            // Заполнить индексами
      {
      for(int i=0; i
         {
         X[i] = new int [size];
         for(int j=0; j
         }
      };
   void SizeSet(int n_size)                     // Измениьть размерность
      {
      if(size == n_size) return;
      X = (int **) realloc(X, n_size*sizeof(int *));
      for(int i=0; i
         {
         if(i
            X[i] = (int *) realloc(X[i], n_size*sizeof(int));
         else
            X[i] = new int [n_size];
         }
      if(n_size>=size)
         {
         for(int i=0; i
            for(int j=0; j
               if(i>=size || j>=size) X[i][j] = 0;
         }
      size = n_size;
      };
   int SizeGet()                            // Возвратить размерность
      {
      return size;
      };
   void Edit(int i, int j, int val)               // Редактировать один элемент
      {
      X[i][j] = val;
      };
   void Copy(Matx &S)                         // Скопировать данные из S
      {
      int min_size = size
      for(int i=0; i
         for(int j=0; j
            X[i][j] = S.X[i][j];
      }
   void Transpose()                           // Транспонировать матрицу
      {
      for(int i=0; i
         for(int j=i+1; j
            {
            X[i][j] = X[i][j] ^ X[j][i];
            X[j][i] = X[i][j] ^ X[j][i];
            X[i][j] = X[i][j] ^ X[j][i];
            }
      }
   void Add(Matx &S)                         // Сложить с матрицой S
      {
      SizeSet(size>S.size?size:S.size);
      for(int i=0; i
         for(int j=0; j
            X[i][j] += S.X[i][j];
      }
   void Subtract(Matx &S)                      // Вычесть матрицу S
      {
      SizeSet(size>S.size?size:S.size);
      for(int i=0; i
         for(int j=0; j
            X[i][j] -= S.X[i][j];
      };
   void Multiply(Matx &S)                      // Домножить на матрицу S
      {
      Matx T(size);
      int i, j, k;
      for(i=0; i
         {
         for(j=0; j
            for(k=0; k
             T.X[i][j] += X[i][k] * S.X[k][j];
         };
      Copy(T);
      };
   long Det()                               // Посчитать определитель
      {
      long result = 0;
      for(int i=0, pos=1, neg=1; i
         {
         for(int j=0; j
            {
            pos *= X[j][i+j
            neg *= X[j][i+j
            }
            if (size == 1) return pos;
            result += pos - neg;
         };
      return result;
      };
   ~Matx()
      {
      delete X;
//      ShowMessage("Деструктор ~Matx() уничтожил матрицу по адресу " + IntToHex((int)this, 8));
      };
// Арифметика в операторах ----------------------------------------------------      
   Matx operator=(Matx S)
      {
      delete X;
      size = S.size;
      X = new int * [size];
      for(int i=0; i
         {
         X[i] = new int [size];
         for(int j=0; j
         }
      this->Copy(S);
      return *this;
      }
   Matx operator*(Matx S)
      {
      Matx T(size);
      int i, j, k;
      for(i=0; i
         {
         for(j=0; j
            for(k=0; k
             T.X[i][j] += X[i][k] * S.X[k][j];
         };
      return T;
      }
   Matx operator+(Matx S)
      {
      Matx T(size);
      T.Copy(*this);
      SizeSet(T.size>S.size?T.size:S.size);
      for(int i=0; i
         for(int j=0; j
            T.X[i][j] += S.X[i][j];
      return T;
      }
   Matx operator-(Matx S)
      {
      Matx T(size);
      T.Copy(*this);
      SizeSet(T.size>S.size?T.size:S.size);
      for(int i=0; i
         for(int j=0; j
            T.X[i][j] -= S.X[i][j];
      return T;
      }
   bool operator<(Matx S)
      {
      return (this->Det()
      }
   bool operator>(Matx S)
      {
      return (this->Det()>S.Det());
      }
   friend operator<<(TStringGrid &O, Matx &S)
      {
      S.Print(&O);
      }
} A, B(1), C(B), T(5);
vector sclad;
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn3Click(TObject *Sender)
{
   A.SizeSet(TrackBar1->Position);
   A.FillSort();
   A.Print(Form1->StringGrid1);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn5Click(TObject *Sender)
{
   B.SizeSet(TrackBar2->Position);
   B.FillSort();
   B.Print(Form1->StringGrid2);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn1Click(TObject *Sender)
{
   Form2->Show();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn4Click(TObject *Sender)
{
   A.SizeSet(TrackBar1->Position);
   A.FillRand();
   A.Print(Form1->StringGrid1);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn6Click(TObject *Sender)
{
   B.SizeSet(TrackBar2->Position);
   B.FillRand();
   B.Print(Form1->StringGrid2);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
   A.Print(Form1->StringGrid1);
   B.Print(Form1->StringGrid2);
   C.Print(Form1->StringGrid3);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::TrackBar1Change(TObject *Sender)
{
   A.SizeSet(Form1->TrackBar1->Position);
   A.Print(Form1->StringGrid1);
   if(Form1->TrackBar1->Position == Form1->TrackBar2->Position)
      Form1->BitBtn17->Enabled = True;
   else
      Form1->BitBtn17->Enabled = False;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::TrackBar2Change(TObject *Sender)
{
   B.SizeSet(Form1->TrackBar2->Position);
   B.Print(Form1->StringGrid2);
   if(Form1->TrackBar1->Position == Form1->TrackBar2->Position)
      BitBtn17->Enabled = True;
   else
      BitBtn17->Enabled = False;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn9Click(TObject *Sender)
{
   A.Copy(B);
   A.Print(StringGrid1);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn11Click(TObject *Sender)
{
   B.Copy(A);
   B.Print(StringGrid2);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn10Click(TObject *Sender)
{
   A.Copy(C);
   A.Print(StringGrid1);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn12Click(TObject *Sender)
{
   B.Copy(C);
   B.Print(StringGrid2);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn13Click(TObject *Sender)
{
   C.SizeSet(A.SizeGet());
   C.Copy(A);
   C.Print(StringGrid3);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn14Click(TObject *Sender)
{
   C.SizeSet(B.SizeGet());
   C.Copy(B);
   C.Print(StringGrid3);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn18Click(TObject *Sender)
{
   C.Transpose();
   C.Print(StringGrid3);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn15Click(TObject *Sender)
{
   C.SizeSet(A.SizeGet());
   C.Copy(A);
   C.Add(B);
   C.Print(StringGrid3);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn16Click(TObject *Sender)
{
   C.SizeSet(A.SizeGet());
   C.Copy(A);
   C.Subtract(B);
   C.Print(StringGrid3);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn17Click(TObject *Sender)
{
   C.SizeSet(A.SizeGet());
   C.Copy(A);
   C.Multiply(B);
   C.Print(StringGrid3);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::StringGrid1SetEditText(TObject *Sender, int ACol,
    int ARow, const AnsiString Value)
{
   if(Value.Length() == 0) return;
   A.Edit(ACol, ARow, StrToInt(Value));
}
//---------------------------------------------------------------------------
void __fastcall TForm1::StringGrid2SetEditText(TObject *Sender, int ACol,
    int ARow, const AnsiString Value)
{
   if(Value.Length() == 0) return;
   B.Edit(ACol, ARow, StrToInt(Value));
}
//---------------------------------------------------------------------------
void __fastcall TForm1::StringGrid3SetEditText(TObject *Sender, int ACol,
    int ARow, const AnsiString Value)
{
   if(Value.Length() == 0) return;
   C.Edit(ACol, ARow, StrToInt(Value));
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn19Click(TObject *Sender)
{
   ShowMessage("Определитель матрицы C равен " + IntToStr(C.Det()));
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn29Click(TObject *Sender)
{
   C = A*B;
   C.Print(StringGrid3);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn27Click(TObject *Sender)
{
   C = A+B;
   C.Print(StringGrid3);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn28Click(TObject *Sender)
{
   C = A-B;
   C.Print(StringGrid3);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn7Click(TObject *Sender)
{
   if (A < C)
      ShowMessage("|A| < |C|");
   else
      ShowMessage("|A| не меньше |C|");
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn8Click(TObject *Sender)
{
   if (B > C)
      ShowMessage("|B| > |C|");
   else
      ShowMessage("|B| не превосходит |C|");
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn20Click(TObject *Sender)
{
   (*StringGrid3)<
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn21Click(TObject *Sender)
{
   Form1->BitBtn22->Enabled = True;
   Form1->BitBtn25->Enabled = True;   
   T.FillRand();
   T.Print(Form1->StringGrid4);
      
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn22Click(TObject *Sender)
{
   sclad.InsSort(T);
   sclad.rez();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn25Click(TObject *Sender)
{
   sclad.Add(T);
   sclad.rez();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn23Click(TObject *Sender)
{
   sclad[Form1->CSpinEdit1->Value - 1].Print(Form1->StringGrid5);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn24Click(TObject *Sender)
{
   sclad.rem(Form1->CSpinEdit1->Value - 1);
   sclad.rez();
}
//---------------------------------------------------------------------------
Вам помог данный материал: Да | Нет
Rambler's Top100   Mini-Soft Soft Исходники Лабораторные # 1,2,3,4
О проекте Mini-Soft.ru   Реклама на сайте
Copyright © Mini-Soft 2003-2009 mini-soft@narod.ru