База знаний студента. Реферат, курсовая, контрольная, диплом на заказ

Содержание:

1.    Теоретический материал. Матрицы……………………………3 стр

2.    Описание программы……………………………………………4 стр

3.    Текст программы………………………………………………..11 стр

4.    Примеры…………………………………………………………

Теоретический материал. Матрицы

Основные определения.

Матрицей А размера т x n называется прямоугольная таблица из m строк и n столбцов, состоящая из чисел или иных математических выражений aij  (называемых элементами матрицы), i=1,2,3…m; j=1,2,3…n. Квадратной матрицей n-го порядка называется матрица размера п x n. Диагональной называется квадратная матрица, у которой все эле­менты вне главной диагонали (т. е. c индексами i != j) равны нулю. Еди­ничной (обозначается Е) называется диагональная матрица с единицами на главной диагонали. Нулевой называется матрица, все элементы кото­рой равны нулю.

Операции над матрицами

Суммой матриц  А = (а_ij) и В =(b_ij) одинакового разме­ра называется матрица С=(с_ij) того же размера, причем с_ij=a_ij+b_ij , для любых i,j.

Произведением матрицы А=(а_ij) на число λ называется матрица В=(b_ij) того же размера, что и матрица А, причем  b_ij = λ а_ij, для любых i,j.

Транспонированной к матрице А = (а_ij) называется матрица А^т = (а^т_ij) такая что,

а^т_ij = а_ji , для любых i,j

Любой квадратной матрице можно поставить в соответствие выражение, которое называется определителем (детерминантом), обозначается det А.

Описание программы

Данная программа предназначена для работы с матрицами. Можно заполнять их самостоятельно, а можно случайным образом, автоматически; причем имеются ввиду дробные числа типа (3/6 или 1*2/3, например). Программа самостоятельно выделяет в дробях целую часть, не зависимо, положительная дробь или отрицательная. В данной программе предусмотрены некоторые действия с матрицами, подробнее о которых речь будет вестись ниже.

В программе работаем с тремя формами, из которых одна основная. В этой форме происходит заполнение матриц, а также находятся кнопки вызова других форм и кнопки действий. Каждый раз результат какого либо действия, кроме нахождения определителя, будет выводится на вторую форму. Если вы хотите умножить матрицу на число, то сначала появится третья форма, предназначенная для ввода числа на которое умножаем матрицы, а потом уже форма с результатом.

В программе использованы визуальные компоненты: Button, RadioButton, String Grid, CSpinEdit, PopupMenu и т.д.

Для работы с дробями, был создан класс drob. Он содержит числитель, знаменатель и целую часть, для выделения которой в классе прописана специальная функция videlen.

class drob

{

    public:

    int chisl;

    int znamen;

    int cel;

    drob ()

    {

        chisl=znamen=cel=0;

    }

    int videlen ()

    {

        if (!cel && chisl && znamen && abs(chisl)>=abs(znamen))

        {

            cel=(int)chisl/znamen;

            chisl=(int)chisl%(int)znamen;

        }

        else

            if (cel && chisl && znamen && abs(chisl)>=abs(znamen))

            {

                cel=cel+((int)chisl/znamen);

                chisl=(int)chisl%(int)znamen;

            }

        return 0;

    }

};

Для считывания числителя и знаменателя любого экземпляра класса дробей, создан класс Анализатора выражений. Который при считывании символа «/»,все что было считано до него заносит в числитель, все что после - в знаменатель. В этом классе прописаны функции преобразования символьных строк в целочисленные значения (Convert), получения (считывания) символов (Get), анализа выражения (что заносить в числитель, что  в знаменатель) (Analiz), и функция вызывающая все эти функции (MAIN).

class Analisation

{

    char *ptr;

    char token [80];

    char ttype;

    drob vrem;

    //-------------------------------------

    void Analiz(double &result)

    {

        register char op;

        double temp;

        Convert(result);

        while((op=*token)=='*' || op=='/' )

        {

            Get();

            Convert(temp);

            switch (op)

            {

                case '*':

                    vrem.cel=result;

                    break;

                case '/':

                    vrem.chisl=result;

                    vrem.znamen=temp;

                    break;

            }

        }

    }

    //-------------------------------------

    void Convert(double &result)

    {

        result=(double)atof(token);

        Get();

        return;

    }

    //-------------------------------------

    void Get()

    {

        register char *temp;

        ttype=0;

        temp=token;

        *temp='';

        if(!*ptr)return;

        while(isspace(*ptr))++ptr;

        if(strchr("/*",*ptr))

        {

            ttype=DELIM;

            *temp++=*ptr++;

        }

        else if(isdigit(*ptr))

        {

            while(!isdelim(*ptr))*temp++=*ptr++;

            ttype=NUMB;

        }

        *temp='';

    }

    //-------------------------------------

    int isdelim(char c)

    {

        if (strchr("/*",c))return 1;

        else return 0;

    }

    //-------------------------------------

    public:

    Analisation()

    {

        ptr=NULL;

    }

    drob MAIN(char*exp)

    {

        double result;

        ptr=exp;

        Get();

        Analiz(result);

        return vrem;

    }

};

Сами матрицы создаются как экземпляры класса matrix, который содержит поля:

размерность матрицы, непосредственно матрицу (типа drob), ее определитель (det), а также функции получения значений размеров матрицы, функцию считывания значений элементов матрицы из StringGrida и функцию нахождения определителя. Помимо всего прочего в классе используется перегрузка операторов сложения, вычитания, умножения и т.д.

class matrix

{

    protected:

    int x,y;

    drob det;

    public:

    drob **matr;

    matrix (int x1, int y1);

    int Getx () { return x; };

    int Gety () { return y; };

    void Read (TStringGrid *sg, Analisation &obj);

    matrix operator* (drob number);

    matrix operator* (int num);

    drob Determinant ();

};

//-------------------------------------

matrix::matrix (int x1, int y1)

{

    x=x1;

    y=y1;

    det.chisl=det.znamen=det.cel=0;

    matr=new drob *[x];

    for (int i=0; i

        matr[i]=new drob [y];

}

//-------------------------------------

void matrix::Read (TStringGrid *sg, Analisation &obj)

{

    char ***temp;

    temp=new char **[x];

    for (int i=0; i

        temp[i]=new char *[y];

    for (int i=0; i

        for (int j=0; j

            temp[i][j]=sg->Cells[j][i].c_str();

    for (int i=0; i

        for (int j=0; j

        {

            matr[i][j]=obj.MAIN(temp[i][j]);

        }

    for (int i=0; i

        delete temp[i];

    delete [] temp;

}

//-------------------------------------

matrix matrix::operator* (drob number)

{

    matrix res (x,y);

    for (int i=0; i

        for (int j=0; j

        {

            res.matr[i][j].chisl=number.chisl*matr[i][j].chisl;

            res.matr[i][j].znamen=number.znamen*matr[i][j].znamen;

        }

    return res;

}

//-------------------------------------

matrix matrix::operator* (int num)

{

    matrix res (x,y);

    for (int i=0; i

        for (int j=0; j

        {

            res.matr[i][j].chisl=num*matr[i][j].chisl;

            res.matr[i][j].znamen=matr[i][j].znamen;

        }

    return res;

   

}

//-------------------------------------

drob matrix::Determinant ()

{

    drob det1;

    drob det2;

    if (x!=y) MessageBox(NULL,"Ну кто так делает :)",

    "ЧАЙНИК!!",MB_ICONEXCLAMATION);

    if(x==2 && y==2)

    {

        det1=matr[0][0]*matr[1][1];

        det2=matr[0][1]*matr[1][0];

        det=det1-det2;

        det.videlen();

    }

    if (x==1 && y==1)

    {

        det=matr[0][0];

        det.videlen();

    }

    return det; }

Текст программы:

#include

#include

#pragma hdrstop

#include "matrix.h"

#include "Resultunit.h"

#include "Numberunit.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma link "CSPIN"

#pragma resource "*.dfm"

TMainForm *MainForm;

//---------------------------------------------------------------------------

///КЛАСС ДРОБЕЙ///

class drob

{

    public:

    int chisl;

    int znamen;

    int cel;

    drob ()

    {

        chisl=znamen=cel=0;

    }

    int videlen ()

    {

        if (!cel && chisl && znamen && abs(chisl)>=abs(znamen))

        {

            cel=(int)chisl/znamen;

            chisl=(int)chisl%(int)znamen;

        }

        else

            if (cel && chisl && znamen && abs(chisl)>=abs(znamen))

            {

                cel=cel+((int)chisl/znamen);

                chisl=(int)chisl%(int)znamen;

            }

        return 0;

    }

 };

drob operator + (drob &m1, drob &m2)

{

    drob res;

    if (m1.znamen==m2.znamen && m1.znamen!=0)

    {

        res.chisl=m1.chisl+m2.chisl;

        res.znamen=m1.znamen;

    }

    else

    {

        res.znamen=m1.znamen*m2.znamen;

        res.chisl=(m1.chisl*m2.znamen)+

        (m2.chisl*m1.znamen);

    }

    return res;

}

drob operator - (drob &m1, drob &m2)

{

    drob res;

    if (m1.znamen==m2.znamen && m1.znamen!=0)

    {

        res.chisl=m1.chisl-m2.chisl;

        res.znamen=m1.znamen;

    }

    else

    {

        res.znamen=m1.znamen*m2.znamen;

        res.chisl=(m1.chisl*m2.znamen)-

        (m2.chisl*m1.znamen);

    }

    return res;

}

drob operator* (drob &g, drob &h)

{

    drob res;

    res.chisl=g.chisl*h.chisl;

    res.znamen=g.znamen*h.znamen;

    return res;

}

drob operator/ (drob &g, drob &h)

{

    drob res;

    res.chisl=g.chisl*h.znamen;

    res.znamen=g.znamen*h.chisl;

    return res;

}

//---------------------------------------------------------------------------

///АНАЛИЗАТОР///

enum types

{

    DELIM=1,NUMB

};

class Analisation

{

    char *ptr;

    char token [80];

    char ttype;

    drob vrem;

    //-------------------------------------

    void Analiz(double &result)

    {

        register char op;

        double temp;

        Convert(result);

        while((op=*token)=='/' )

        {

            Get();

            Convert(temp);

            switch (op)

            {

                case '/':

                    vrem.chisl=result;

                    vrem.znamen=temp;

                    break;

            }

        }

    }

    //-------------------------------------

    void Convert(double &result)

    {

        result=(double)atof(token);

        Get();

        return;

    }

    //-------------------------------------

    void Get()

    {

        register char *temp;

        ttype=0;

        temp=token;

        *temp='';

        if(!*ptr)return;

        while(isspace(*ptr))++ptr;

        if(strchr("/*",*ptr))

        {

            ttype=DELIM;

            *temp++=*ptr++;

        }

        else if(isdigit(*ptr))

        {

            while(!isdelim(*ptr))*temp++=*ptr++;

            ttype=NUMB;

        }

        *temp='';

    }

    //-------------------------------------

    int isdelim(char c)

    {

        if (strchr("/*",c))return 1;

        else return 0;

    }

    //-------------------------------------

    public:

    Analisation()

    {

        ptr=NULL;

    }

    drob MAIN(char*exp)

    {

        double result;

        ptr=exp;

        Get();

        Analiz(result);

        return vrem;

    }

 };

//---------------------------------------------------------------------------

class matrix

{

    protected:

    int x,y;

    drob det;

    public:

    drob **matr;

    matrix (int x1, int y1);

    int Getx () { return x; };

    int Gety () { return y; };

    void Read (TStringGrid *sg, Analisation &obj);

    matrix operator* (drob number);

    matrix operator* (int num);

    drob Determinant ();

};

//-------------------------------------

matrix::matrix (int x1, int y1)

{

    x=x1;

    y=y1;

    det.chisl=det.znamen=det.cel=0;

    matr=new drob *[x];

    for (int i=0; i

        matr[i]=new drob [y];

}

//-------------------------------------

void matrix::Read (TStringGrid *sg, Analisation &obj)

{

    char ***temp;

    temp=new char **[x];

    for (int i=0; i

        temp[i]=new char *[y];

    for (int i=0; i

        for (int j=0; j

            temp[i][j]=sg->Cells[j][i].c_str();

    for (int i=0; i

        for (int j=0; j

        {

            matr[i][j]=obj.MAIN(temp[i][j]);

        }

    for (int i=0; i

        delete temp[i];

    delete [] temp;

}

//-------------------------------------

matrix matrix::operator* (drob number)

{

    matrix res (x,y);

    for (int i=0; i

        for (int j=0; j

        {

            res.matr[i][j].chisl=number.chisl*matr[i][j].chisl;

            res.matr[i][j].znamen=number.znamen*matr[i][j].znamen;

        }

    return res;

}

//-------------------------------------

matrix matrix::operator* (int num)

{

    matrix res (x,y);

    for (int i=0; i

        for (int j=0; j

        {

            res.matr[i][j].chisl=num*matr[i][j].chisl;

            res.matr[i][j].znamen=matr[i][j].znamen;

        }

    return res;

}

//-------------------------------------

drob matrix::Determinant ()

{

    drob det1;

    drob det2;

    if (x!=y) MessageBox(NULL,"Не хорошо так делать :)",

    "ЧАЙНИК!!",MB_ICONEXCLAMATION);

    if(x==2 && y==2)

    {

        det1=matr[0][0]*matr[1][1];

        det2=matr[0][1]*matr[1][0];

        det=det1-det2;

        det.videlen();

    }

    if (x==1 && y==1)

    {

        det=matr[0][0];

        det.videlen();

    }

    return det;

}

//---------------------------------------------------------------------------

matrix  Transposing (matrix &t)

{

    matrix result (t.Gety (), t.Getx());

    for (int i=0; i

        for (int j=0; j

        {

            result.matr[i][j].cel=t.matr[j][i].cel;

            result.matr[i][j].chisl=t.matr[j][i].chisl;

            result.matr[i][j].znamen=t.matr[j][i].znamen;

        }

    return result;

}

//---------------------------------------------------------------------------

matrix operator + (matrix &m1, matrix &m2)

{

    matrix res (m1.Getx(),m1.Gety());

    for (int i=0; i

        for (int j=0; j

        {

            if (m1.matr[i][j].znamen==m2.matr[i][j].znamen && m1.matr[i][j].znamen!=0)

            {

                res.matr[i][j].chisl=m1.matr[i][j].chisl+m2.matr[i][j].chisl;

                res.matr[i][j].znamen=m1.matr[i][j].znamen;

            }

            else

            {

                //            res.matr[i][j].cel=m1.matr[i][j].cel+m2.matr[i][j].cel;

                res.matr[i][j].znamen=m1.matr[i][j].znamen*m2.matr[i][j].znamen;

                res.matr[i][j].chisl=(m1.matr[i][j].chisl*m2.matr[i][j].znamen)+

                (m2.matr[i][j].chisl*m1.matr[i][j].znamen);

            }

        }

    return res;

}

//---------------------------------------------------------------------------

matrix operator - (matrix &m1, matrix &m2)

{

    matrix res (m1.Getx(),m1.Gety());

    for (int i=0; i

        for (int j=0; j

        {

            if (m1.matr[i][j].znamen==m2.matr[i][j].znamen && m1.matr[i][j].znamen!=0)

            {

                res.matr[i][j].chisl=m1.matr[i][j].chisl-m2.matr[i][j].chisl;

                res.matr[i][j].znamen=m1.matr[i][j].znamen;

            }

            else

            {

                res.matr[i][j].cel=m1.matr[i][j].cel-m2.matr[i][j].cel;

                res.matr[i][j].znamen=m1.matr[i][j].znamen*m2.matr[i][j].znamen;

                res.matr[i][j].chisl=(m1.matr[i][j].chisl*m2.matr[i][j].znamen)-

                (m2.matr[i][j].chisl*m1.matr[i][j].znamen);

            }

        }

    return res;

}

//---------------------------------------------------------------------------

drob chislo;

int n=1,m=1;

int k=1,l=1;

//---------------------------------------------------------------------------

__fastcall TMainForm::TMainForm(TComponent* Owner)

    : TForm(Owner)

    {

        chislo.chisl=1;   //значение по умолчанию

        chislo.znamen=2;

    }

//---------------------------------------------------------------------------

void __fastcall TMainForm::SEdit1Change(TObject *Sender)

{

    if (RBtn1->Checked)

    {

        n=SEdit1->Text.ToIntDef(5);

        sg1->RowCount=n;

    }

    if (RBtn2->Checked)

    {

        m=SEdit1->Text.ToIntDef(5);

        sg1->ColCount=m;

    }

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::SEdit2Change(TObject *Sender)

{

    if (RBtn3->Checked)

    {

        k=SEdit2->Text.ToIntDef(5);

        sg2->RowCount=k;

    }

    if (RBtn4->Checked)

    {

        l=SEdit2->Text.ToIntDef(5);

        sg2->ColCount=l;

    }

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::RBtn1Click(TObject *Sender)

{

    SEdit1->Text=IntToStr(1);

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::RBtn2Click(TObject *Sender)

{

    SEdit1->Text=IntToStr(1);

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::RBtn3Click(TObject *Sender)

{

    SEdit2->Text=IntToStr(1);

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::RBtn4Click(TObject *Sender)

{

    SEdit2->Text=IntToStr(1);

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::Btn1Click(TObject *Sender)

{

    Application->Terminate();

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::Btn2Click(TObject *Sender)

{

    Analisation ob,ob1;

    matrix first (n,m);

    matrix second (k,l);

    first.Read(sg1,ob);

    second.Read(sg2,ob1);

    matrix res=Transposing(first);

    Resform->sg3->RowCount=res.Getx();

    Resform->sg3->ColCount=res.Gety();

    for(int i=0; i

        for (int j=0; j

            res.matr[i][j].videlen();

    for (int i=0; i

        for (int j=0; j

        {

            Resform->sg3->Cells[j][i]=IntToStr(res.matr[i][j].cel)+

            "*"+IntToStr(res.matr[i][j].chisl)+

            "/"+IntToStr(res.matr[i][j].znamen);

        }

    Resform->Box1->Visible=true;

    Resform->ShowModal();

    if (Resform->Box1->Checked)

    {

        matrix res1=Transposing (second);

        Resform->sg3->RowCount=res1.Getx();

        Resform->sg3->ColCount=res1.Gety();

        for(int i=0; i

            for (int j=0; j

                res1.matr[i][j].videlen();

        for (int i=0; i

            for (int j=0; j

            {

                Resform->sg3->Cells[j][i]=IntToStr(res1.matr[i][j].cel)+

                "*"+IntToStr(res1.matr[i][j].chisl)+

                "/"+IntToStr(res1.matr[i][j].znamen);

            }

        Resform->Box1->Visible=false;

        Resform->ShowModal();

       

    }

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::Btn3Click(TObject *Sender)

{

    Analisation ob,ob1;

    matrix first (n,m);

    matrix second (k,l);

    first.Read(sg1,ob);

    second.Read(sg2,ob1);

    if (first.Getx()==second.Getx() &&

    first.Gety()==second.Gety())

    {

        matrix res=first+second;

        Resform->sg3->RowCount=res.Getx();

        Resform->sg3->ColCount=res.Gety();

        for (int i=0; i

            for (int j=0; j

                res.matr[i][j].videlen();

        for (int i=0; i

            for (int j=0; j

            {

                Resform->sg3->Cells[j][i]="";

                Resform->sg3->Cells[j][i]=IntToStr(res.matr[i][j].cel)+"*"+

                IntToStr(res.matr[i][j].chisl)+

                "/"+IntToStr(res.matr[i][j].znamen);

            }

        Resform->ShowModal();

    }

    else MessageBox (NULL,"Ну кто так складывает","ЧАЙНИК!!",MB_ICONEXCLAMATION );

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::C1Click(TObject *Sender)

{

    for (int i=0; iRowCount; i++)

        for (int j=0; jColCount; j++)

            sg1->Cells[j][i]=IntToStr(1+random(6))+

            "/"+IntToStr(1+random(6));

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::C2Click(TObject *Sender)

{

    for (int i=0; iRowCount; i++)

        for (int j=0; jColCount; j++)

            sg2->Cells[j][i]=IntToStr(1+random(6))+

            "/"+IntToStr(1+random(6));

   

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::Btn4Click(TObject *Sender)

{

    Analisation ob,ob1;

    matrix first (n,m);

    matrix second (k,l);

    first.Read(sg1,ob);

    second.Read(sg2,ob1);

    if (first.Getx()==second.Getx() &&

    first.Gety()==second.Gety())

    {

        matrix res=first-second;

        Resform->sg3->RowCount=res.Getx();

        Resform->sg3->ColCount=res.Gety();

        for (int i=0; i

            for (int j=0; j

                res.matr[i][j].videlen();

        for (int i=0; i

            for (int j=0; j

            {

                Resform->sg3->Cells[j][i]="";

                Resform->sg3->Cells[j][i]=IntToStr(res.matr[i][j].cel)+"*"+

                IntToStr(res.matr[i][j].chisl)+

                "/"+IntToStr(res.matr[i][j].znamen);

            }

        Resform->ShowModal();

    }

    else MessageBox (NULL,"Ну кто так отнимает","ЧАЙНИК!!",MB_ICONEXCLAMATION );

 }

//---------------------------------------------------------------------------

void __fastcall TMainForm::N1Click(TObject *Sender)

{

    for (int i=0; iRowCount; i++)

        for (int j=0; jColCount; j++)

            sg1->Cells[j][i]="";

    Panel1->Caption="";

   

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::N2Click(TObject *Sender)

{

    for (int i=0; iRowCount; i++)

        for (int j=0; jColCount; j++)

            sg2->Cells[j][i]="";

    Panel2->Caption="";

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::Btn5Click(TObject *Sender)

{

    Nunit->ShowModal();

    Analisation ob,ob1,ob2;

    chislo=ob.MAIN(Nunit->Edit->Text.c_str());

    matrix first (n,m);

    matrix second (k,l);

    first.Read(sg1,ob1);

    second.Read(sg2,ob2);

    matrix res1 (first.Getx(), first.Gety());

    matrix res2 (second.Getx(), second.Gety());

    if (Nunit->RBtn1->Checked)

    {

        res1=first.operator *(chislo);

        for (int i=0; i

            for (int j=0; j

                res1.matr[i][j].videlen();

        Resform->sg3->RowCount=res1.Getx();

        Resform->sg3->ColCount=res1.Gety();

        for (int i=0; i

            for (int j=0; j

            {

                Resform->sg3->Cells[j][i]="";

                Resform->sg3->Cells[j][i]=IntToStr(res1.matr[i][j].cel)+

                "*"+IntToStr(res1.matr[i][j].chisl)+"/"+

                IntToStr(res1.matr[i][j].znamen);

            }

        Resform->Box1->Visible=true;

        Resform->ShowModal();

    }

    if (Nunit->RBtn2->Checked)

    {

        res1=first.operator *(Nunit->Edit->Text.ToInt());

        for (int i=0; i

            for (int j=0; j

                res1.matr[i][j].videlen();

        Resform->sg3->RowCount=res1.Getx();

        Resform->sg3->ColCount=res1.Gety();

        for (int i=0; i

            for (int j=0; j

            {

                Resform->sg3->Cells[j][i]="";

                Resform->sg3->Cells[j][i]=IntToStr(res1.matr[i][j].cel)+

                "*"+IntToStr(res1.matr[i][j].chisl)+"/"+

                IntToStr(res1.matr[i][j].znamen);

            }

        Resform->Box1->Visible=true;

        Resform->ShowModal();

    }

    if (Resform->Box1->Checked)

    {

        if (Nunit->RBtn1->Checked)

        {

            res2=second.operator *(chislo);

            for (int i=0; i

                for (int j=0; j

                    res2.matr[i][j].videlen();

            Resform->sg3->RowCount=res2.Getx();

            Resform->sg3->ColCount=res2.Gety();

            for (int i=0; i

                for (int j=0; j

                {

                    Resform->sg3->Cells[j][i]="";

                    Resform->sg3->Cells[j][i]=IntToStr(res2.matr[i][j].cel)+

                    "*"+IntToStr(res2.matr[i][j].chisl)+"/"+

                    IntToStr(res2.matr[i][j].znamen);

                }

            Resform->Box1->Visible=false;

            Resform->ShowModal();

        }

        if (Nunit->RBtn2->Checked)

        {

            res2=second.operator *(Nunit->Edit->Text.ToInt());

            for (int i=0; i

                for (int j=0; j

                    res2.matr[i][j].videlen();

            Resform->sg3->RowCount=res2.Getx();

            Resform->sg3->ColCount=res2.Gety();

            for (int i=0; i

                for (int j=0; j

                {

                    Resform->sg3->Cells[j][i]="";

                    Resform->sg3->Cells[j][i]=IntToStr(res2.matr[i][j].cel)+

                    "*"+IntToStr(res2.matr[i][j].chisl)+"/"+

                    IntToStr(res2.matr[i][j].znamen);

                }

            Resform->Box1->Visible=false;

            Resform->ShowModal();

        }

    }

}

//---------------------------------------------------------------------------

void __fastcall TMainForm::Btn6Click(TObject *Sender)

{

    Analisation ob1,ob2;

    matrix first (n,m);

    matrix second (k,l);

    first.Read(sg1,ob1);

    second.Read(sg2,ob2);

    drob temp1,temp2;

    temp1=first.Determinant();

    temp2=second.Determinant();

    Panel1->Caption="Определитель первой: "+

    IntToStr(temp1.cel)+"*"+IntToStr(temp1.chisl)+"/"

    +IntToStr(temp1.znamen);

    Panel2->Caption="Определитель второй: "+

    IntToStr(temp2.cel)+"*"+IntToStr(temp2.chisl)+"/"

    +IntToStr(temp2.znamen);

}

Пример использования данной программы:

    Общий вид формы после запуска приложения (Рис. 1).

Рис.1

После определения размеров матриц, можно заполнить их вручную либо случайными числами, как показано на рисунке 2 и 3. Причём работать можно с дробными числами (вводить дроби и результат получать также дробный, прописано выделение целой части).

                               Рис.2                                                               Рис.3

В данной программе предусмотрены такие действия над матрицами:

A.   сложение;

B.    вычитание;

C.   транспонирование;

D.   умножение на число;

E.    вычисление простейших определителей;

Пример сложения двух матриц в данной программе продемонстрирован

на рис.4 и 5.

Рис.4

В случае, если вы попытаетесь сложить матрицы не одинаковых размеров, появится сообщение об ошибке;

Аналогично с разностью двух матриц.

                             Рис.5

Пример транспонирования матриц продемонстрирован на рис. 6

Рис.6

В данной программе есть возможность умножать матрицы на целое либо дробное число (см. рис 7 и 8)

Рис.7

                                Рис. 8

Пример вычисления простейших определителей продемонстрирован на рис 9.

Содержание: 1. Теоретический материал. Матрицы……………………………3 стр 2. Описание программы……………………………………………4 стр 3. Текст программы………………………………………………..11 стр 4. Примеры………………………………………………………… Теоре

 

• 14:21 05 Июля 2016
  Российско-китайский медуниверситет откроет магистерскую программу по TCM
• 01:21 05 Июля 2016
  На форуме МГУ Россия и Китай обсудят научно-образовательное сотрудничество
• 11:00 04 Июля 2016
  Реморенко: "ЕГЭ-туризм" в России сходит на нет
• 10:52 04 Июля 2016
  Летняя российско-австрийская школа откроется в Москве
• 15:31 01 Июля 2016
  В СПбГУ могут воссоздать географический факультет

Заказать уникальную работу