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='\0';

        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='\0';

    }

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

    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<x; i++)

        matr[i]=new drob [y];

}

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

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

{

    char ***temp;

    temp=new char **[x];

    for (int i=0; i<x; i++)

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

    for (int i=0; i<x; i++)

        for (int j=0; j<y; j++)

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

    for (int i=0; i<x; i++)

        for (int j=0; j<y; j++)

        {

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

        }

    for (int i=0; i<x; i++)

        delete temp[i];

    delete [] temp;

}

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

matrix matrix::operator* (drob number)

{

    matrix res (x,y);

    for (int i=0; i<x; i++)

        for (int j=0; j<y; 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<x; i++)

        for (int j=0; j<y; 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<t.Gety(); i++)

        for (int j=0; j<t.Getx(); 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<res.Getx(); i++)

        for (int j=0; j<res.Gety(); 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<res.Getx(); i++)

        for (int j=0; j<res.Gety(); 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);

}

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

Страницы: 1, 2, 3