Форум программистов, компьютерный форум CyberForum.ru

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
Рейтинг: Рейтинг темы: голосов - 10, средняя оценка - 4.90
тАрас
Сообщений: n/a
#1

Написать программу, которая умножает матрицы.... Курсач горит!!!!! - C++

10.06.2008, 20:38. Просмотров 1237. Ответов 4
Метки нет (Все метки)

Кто это знает, и может помочь в написании слейдущей программы, помогите пожайлуста:
Написать программу, которая умножает матрицы, считывает их из файла, записываемых в новом файле с применениям динамической памяти!!!
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
10.06.2008, 20:38     Написать программу, которая умножает матрицы.... Курсач горит!!!!!
Посмотрите здесь:

Написать программу, которая находит сумму строк матрицы C++
C++ Написать программу, которая позволяет осуществить ввод матрицы произвольного размера
C++ Написать программу которая вычисляет определитель квадратной матрицы
C++ Написать программу, которая определяет строку квадратной матрицы.
C++ Написать программу, которая определяет самую длинную серию одинаковых элементов матрицы
C++ написать программу которая суммирует матрицы
C++ Написать программу которая определяет сумму в строке квадратной матрицы
C++ Написать программу, которая увеличивает положительные элементы матрицы
C++ Написать программу, которая на основе матрицы А nxm
C++ Написать программу, которая будет обращать в ноль элемент матрицы в случае выполнения условия
C++ Написать программу, которая умножает один массив на другой
Как написать программу, которая меняет местами первую строку и последний столбец квадратной матрицы? C++

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Vourhey
Почетный модератор
6473 / 2248 / 123
Регистрация: 29.07.2006
Сообщений: 12,635
10.06.2008, 20:42     Написать программу, которая умножает матрицы.... Курсач горит!!!!! #2
Какого рода помощь нужна?
_prAktikAnt_
2 / 2 / 0
Регистрация: 10.06.2008
Сообщений: 17
10.06.2008, 20:49     Написать программу, которая умножает матрицы.... Курсач горит!!!!! #3
Вот мой класс матриц посмотри
Код
#ifndef MatrixClass
#define MatrixClass
//#include "Vector3d.h"
enum MatrixType {NORMAL,DIAGONALS};
enum MatrixError {UNENQUAL=1};
//-----------------------------------------------------------------------------
class Matrix
 {
   private:
  int M;
  int N;
  double **itsMatrix;
         bool Square;
         MatrixType type;
         void Init(int,int,MatrixType);
   public:
         Matrix(int,int,MatrixType); //конструктор-по-умолчанию
  Matrix(int,int,const double*);  //не-для-диагональной
         //указатели-после-использования-функции-удалить
         //Если-тип-матрицы-DIAGONALS-то-l--это-количество-элементов
         //на-главной-диагонали-h--это-количество-диагоналей
         Matrix(int,int,MatrixType,double**); //для-диагональной-и-не-только
         //диагонали-считаются-с-правого-верхнего-угла
  Matrix(const Matrix&);
         //Matrix(const Matrix*);
  ~Matrix();
  Matrix& operator=(const Matrix&);
  Matrix& operator=(double*);
  Matrix operator*(const Matrix&);
 // Vector3d operator*(Vector3d&);
  Matrix operator+(const Matrix&);
  Matrix operator-(const Matrix&);
  Matrix operator!();
         void Nuller();
  double itsValue(int offset1,int offset2);
         double DiagValue(int diagNumb,int diagIndex);
  double Det();
  void Give(int,double*);
  void SetData(int n,int m,double val);
         bool isEmpty();
         int getRowCount(){return M;};
         int getColCount(){return N;};
         MatrixType inline getMatrixType(){return type;};
 };
//-----------------------------------------------------------------------------
#endif
Реализация функции смотри operatior*
Код
#include "Matrix.h"
#include  "stdlib.h"
//------------------------------------------------------------------------------
void Matrix::Init(int n1,int n2,MatrixType t)
 {
   if(t==NORMAL)
    {
      itsMatrix = new double*[n1];
      for(int i=0;i<n1;i++)
       {
         itsMatrix[i]=new double[n2];
       }
    }
   if(t==DIAGONALS)
    {
      itsMatrix=new double*[n2];
      int index;
      for(int i=0;i<n2;i++)
       {
         index=n1-abs(n2/2-i);
         itsMatrix[i]=new double[index];
       }
    }
 }
//------------------------------------------------------------------------------
Matrix::Matrix(int n1,int n2,MatrixType t)
  {
   M=n1;N=n2;
   if(t==NORMAL)
    {
      itsMatrix = new double*[M];
      for(int i=0;i<M;i++)
       {
         itsMatrix[i]=new double[N];
       }
      Square=(M==N);
    }
   if(t==DIAGONALS)
    {
      itsMatrix=new double*[N];
      int index;
      for(int i=0;i<N;i++)
       {
         index=M-abs(N/2-i);
         itsMatrix[i]=new double[index];
       }
      Square=true;
    }
    type=t;
  }
//------------------------------------------------------------------------------
Matrix::Matrix(int n1,int n2,const double *vals)
 {
  Init(n1,n2,NORMAL);
  M=n1;N=n2;
  Square=(M==N);
  type=NORMAL;
  for(int i=0;i<M;i++)
   {
  for(int j=0;j<N;j++)
   {
            itsMatrix[i][j]=vals[M*i+j];
   }
   }
 }
//------------------------------------------------------------------------------
Matrix::Matrix(int l,int h,MatrixType t,double **mas)
 {
   Init(l,h,t);
   M=l,N=h;
   if(t==NORMAL)
    {
      for(int i=0;i<M;i++)
       for(int j=0;j<N;j++)
        {
          itsMatrix[i][j]=mas[i][j];
        }
      Square=(M==N);
    }
   if(t==DIAGONALS)
    { //если-дигональная-то-количество-элементов-на-главной-диагонали-l
      //h--это-количество-диагоналей.(нечетное)
      int index;
      for(int i=0;i<N;i++)
       {
         index=M-abs(N/2-i);
         for(int j=0;j<index;j++)
          {
            itsMatrix[i][j]=mas[i][j];
          }
       }
      Square=true;
    }
    type=t;
 }
//------------------------------------------------------------------------------
Matrix::Matrix(const Matrix & rhs)
 {
  Init(rhs.M,rhs.N,rhs.type);
  M=rhs.M;
  N=rhs.N;
  if(rhs.type==NORMAL)
   {
    for(int i=0;i<M;i++)
     {
       for(int j=0;j<N;j++)
        {
         itsMatrix[i][j]=rhs.itsMatrix[i][j];
        }
     }
   }
  if(rhs.type==DIAGONALS)
    { //если-дигональная-то-количество-элементов-на-главной-диагонали-M
      //N--это-количество-диагоналей.(нечетное)
      int index;
      for(int i=0;i<N;i++)
       {
         index=M-abs(N/2-i);
         for(int j=0;j<index;j++)
          {
            itsMatrix[i][j]=rhs.itsMatrix[i][j];
          }
       }
    }
    type=rhs.type;
    Square=rhs.Square;
 }
//------------------------------------------------------------------------------
Matrix::~Matrix()
 {
  if(type==NORMAL)
   {
    for(int j=0;j<M;j++)
     {
       delete [] itsMatrix[j];
     }
   }
  if(type==DIAGONALS)
   {
     for(int i=0;i<N;i++)
      {
        delete [] itsMatrix[i];
      }
   }
   M=N=0;
   delete [] itsMatrix;
   itsMatrix=NULL;
 }
//------------------------------------------------------------------------------
Matrix & Matrix::operator=(const Matrix & rhs)
 {
  if(this==&rhs)return *this;
  M=rhs.M;
  N=rhs.N;
  if(type==NORMAL)
   {
     for(int i=0;i<M;i++)
      {
   for(int j=0;j<N;j++)
    {
   itsMatrix[i][j]=rhs.itsMatrix[i][j];
    }
      }
    }
   if(type==DIAGONALS)
    {
      int index;
      for(int i=0;i<N;i++)
       {
         index=M-abs(N/2-i);
         for(int j=0;i<index;j++)
          {
            itsMatrix[i][j]=rhs.itsMatrix[i][j];
          }
       }
    }
   Square=rhs.Square;
   type=rhs.type;
   return *this;
 }
//------------------------------------------------------------------------------
Matrix & Matrix::operator=(double *mas)
 {
  if(type==NORMAL)
   {
     for(int i=0;i<M;i++)
      {
  for(int j=0;j<N;j++)
   {
    itsMatrix[i][j]=mas[M*i+j];
   }
      }
   }
   return *this;
 }
//------------------------------------------------------------------------------
Matrix Matrix::operator*(const Matrix & rhs)
 {
   Matrix Mx(M,N,type);
   Mx.Nuller();
   if(M!=rhs.M && N!=rhs.N)throw UNENQUAL;
   if(type==NORMAL)
    {
      for(int i=0;i<M;i++)
     {
  for(int l=0;l<N;l++)
   {
  for(int j=0;j<N;j++)
   {
     Mx.itsMatrix[i][l]+=itsMatrix[i][j]*rhs.itsMatrix[j][l];
   }
   }
 }
    }
   return Mx;
 }
//------------------------------------------------------------------------------
Matrix  Matrix::operator+(const Matrix & rhs)
 {
  Matrix Mx(M,N,type);
  Mx.Nuller();
  if(M!=rhs.M && N!=rhs.N)throw UNENQUAL;
  if(type==NORMAL)
   {
     for(int i=0;i<M;i++)
      {
   for(int j=0;j<N;j++)
    {
   Mx.itsMatrix[i][j]+=itsMatrix[i][j]+rhs.itsMatrix[i][j];
    }
      }
   }
  if(type==DIAGONALS)
   {
      int index;
      for(int i=0;i<N;i++)
       {
         index=M-abs(N/2-i);
         for(int j=0;j<index;j++)
          {
            Mx.itsMatrix[i][j]+=itsMatrix[i][j]+rhs.itsMatrix[i][j];
          }
       }
   }
   Mx.type=type;
   Mx.Square=Square;
   return Mx;
 }
//------------------------------------------------------------------------------
/*Vector3d Matrix::operator*(Vector3d & vect)
 {
 Matrix temp(1,4);
 temp.SetData(0,0,vect.x);
 temp.SetData(0,1,vect.y);
 temp.SetData(0,2,vect.z);
 temp.SetData(0,3,1);
 temp=temp*(*this);
 Vector3d result;
  if(temp.itsValue(0,3))
   {
  result.x=(temp.itsValue(0,0)*(1/temp.itsValue(0,3)));
  result.y=(temp.itsValue(0,1)*(1/temp.itsValue(0,3)));
  result.z=(temp.itsValue(0,2)*(1/temp.itsValue(0,3)));
   }
   return result;
 } */
//------------------------------------------------------------------------------
Matrix Matrix::operator-(const Matrix & rhs)
 {
  Matrix Mx(M,N,type);
  Mx.Nuller();
  if(M!=rhs.M && N!=rhs.N)throw UNENQUAL;
  if(type==NORMAL)
   {
     for(int i=0;i<M;i++)
      {
   for(int j=0;j<N;j++)
    {
   Mx.itsMatrix[i][j]+=itsMatrix[i][j]-rhs.itsMatrix[i][j];
    }
      }
   }
  if(type==DIAGONALS)
   {
      int index;
      for(int i=0;i<N;i++)
       {
         index=M-abs(N/2-i);
         for(int j=0;j<index;j++)
          {
            Mx.itsMatrix[i][j]+=itsMatrix[i][j]-rhs.itsMatrix[i][j];
          }
       }
   }
   Mx.type=type;
   Mx.Square=Square;
   return Mx;
 }
//------------------------------------------------------------------------------
Matrix Matrix::operator!()
 {
   Matrix Eds(M,N,type);
    Eds.Nuller();
 if(Square)
  {
   if(type==NORMAL)
    {
       for(int i=0;i<M;i++)
 {
   for(int j=0;j<N;j++)
    {
  if(i==j)Eds.itsMatrix[i][j]=1.0;
    }
 }
       Eds.type=NORMAL;
       Eds.Square=true;
      double m=0.0,m1=0.0;
      bool chet=true;
      for(int k=0;k<N;k++)
       {
  m1=itsMatrix[k][k];
  for(int i=0;i<M;i++)
   {
  m=itsMatrix[i][k];
  for(int j=0;j<N;j++)
   {
     if(chet)
   {
    if(m1!=0)
    {
     itsMatrix[k][j]/=m1;
     Eds.itsMatrix[k][j]/=m1;
    }
   }
   if(i!=k)
   {
    itsMatrix[i][j]-=itsMatrix[k][j]*m;
    Eds.itsMatrix[i][j]-=Eds.itsMatrix[k][j]*m;
   }
   }chet=false;
   }chet=true;
       }
    }
  }
   Eds.type=type;
   Eds.Square=true;
   return Eds;
 }
//------------------------------------------------------------------------------
//для-диагональной
double Matrix::DiagValue(int diagNumb,int diagIndex)
 {
   if(diagIndex>=M || diagNumb>=N)return 0.0;
   if(type==DIAGONALS)
    {
      int index=M-abs(N/2-diagNumb);
      if(diagIndex>=index)return 0.0;
    }
   return itsMatrix[diagNumb][diagIndex];
 }
//------------------------------------------------------------------------------
double Matrix::itsValue(int offset1,int offset2)
 {
   if(type==DIAGONALS)
    {
     if(offset1>=M || offset2>=M)return 0.0;
     int i,j;
     if(offset2>offset1)
      {
        int k=offset2-offset1;
        i=N/2-k;
        j=offset1;
      }
     else
      {
        int k=offset1-offset2;
        i=N/2+k;
        j=offset2;
      }
      if(i<0 || i>=N)return 0.0;
      return itsMatrix[i][j];
    }
   if(offset1>=M || offset2>=N)return 0.0;
   return itsMatrix[offset1][offset2];
 }
//------------------------------------------------------------------------------
double Matrix::Det()
 {
   double m1=0.0,m2=0.0;
   double det=1.0;
  if(Square)
   {
     if(type==NORMAL)
      {
        Matrix detM(*this);
        for(int k=0;k<M;k++)
  {
    m1=detM.itsMatrix[k][k];
    for(int i=0;i<M;i++)
     {
   m2=detM.itsMatrix[i][k]/m1;
   for(int j=0;j<N;j++)
    {
     if(i>k)
   {
    itsMatrix[i][j]-=detM.itsMatrix[k][j]*m2;
   }
    }
     }
  }
        for(int i=0;i<M;i++)
  {
    det*=detM.itsMatrix[i][i];
  }
      }
   }
   return det;
 }
//------------------------------------------------------------------------------
void Matrix::Give(int n,double *mas)
 {
  M=N=n;
  for(int i=0;i<n;i++)
  {
 for(int j=0;j<n;j++)
  {
   itsMatrix[i][j]=mas[n*i+j];
  }
  }
 }
//------------------------------------------------------------------------------
void Matrix::SetData(int n,int m,double val)
 {
   if(type==DIAGONALS)
    {
     if(n>=M || n>=M)return;
     int i,j;
     if(m>n)
      {
        int k=m-n;
        i=N/2-k;
        j=n;
      }
     else
      {
        int k=n-m;
        i=N/2+k;
        j=m;
      }
      if(i<0 || i>=N)return;
      itsMatrix[i][j]=val;
    }
   if(type==NORMAL)
    {
      if(n>=M || m>=N)return;
      itsMatrix[n][m]=val;
    }  
 }
//------------------------------------------------------------------------------
void Matrix::Nuller()
 {
  if(type==NORMAL)
   {
     for(int i=0;i<M;i++)
      for(int j=0;j<N;j++)
       {
         itsMatrix[i][j]=0.0;
       }
   }
  if(type==DIAGONALS)
   {
      int index;
      for(int i=0;i<N;i++)
       {
         index=M-abs(N/2-i);
         for(int j=0;j<index;j++)
          {
            itsMatrix[i][j]=0.0;
          }
       }
   }
 }
//------------------------------------------------------------------------------
bool Matrix::isEmpty()
 {
   if(type==NORMAL)
    {
      for(int i=0;i<M;i++)
       for(int j=0;j<N;j++)
        {
          if(itsMatrix[i][j]!=0.0)return false;
        }
    }
   if(type==DIAGONALS)
    {
      int index;
      for(int i=0;i<N;i++)
       {
        index=M-abs(N/2-i);
        for(int j=0;j<index;j++)
         {
           if(itsMatrix[i][j]!=0.0)return false;
         }
       }
    }
   return true;
 }
//------------------------------------------------------------------------------
тАрас
Сообщений: n/a
10.06.2008, 22:56     Написать программу, которая умножает матрицы.... Курсач горит!!!!! #4
Цитата Сообщение от Vayrhiu Посмотреть сообщение
Какого рода помощь нужна?
Мне срочно надо сделать курсовую, а у меня плохо получаеться.. :'(Так вот я и прошу помощи, может кто быстро сможет это сделать или у кого-то есть уже готовая... В тако плане!






dioxidin
130 / 97 / 1
Регистрация: 21.11.2007
Сообщений: 544
16.06.2008, 12:19     Написать программу, которая умножает матрицы.... Курсач горит!!!!! #5
Смотри там...
В сырцах класс матриц и действия над ними..
Yandex
Объявления
16.06.2008, 12:19     Написать программу, которая умножает матрицы.... Курсач горит!!!!!
Ответ Создать тему
Опции темы

Текущее время: 00:07. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru