Автор работы: Пользователь скрыл имя, 30 Ноября 2013 в 13:35, курсовая работа
В настоящее время не существует методов, которые в одинаковой мере были бы хороши для всех систем ЛАУ. Почти все методы являются ориентированными и учитывают тем или иным образом специальные свойства матриц систем ЛАУ.
В курсовом проекте я рассматриваю метод скорейшего спуска. Этот метод не входит в число методов, которые широко используются и часто встречаются в литературе. Он реже используется в практике вычислений, но тем не менее содержит глубокие идеи и входит в основы теории вычислительной алгебры.
Введение………………………………………………………...2
1. Метод градиента (метод скорейшего спуска) для случая системы нелинейных уравнений……………………….……….3
2. Метод скорейшего спуска для случая системы линейных уравнений…………………………………………………………..11
3. Свойства приближений метода скорейшего спуска……17
Заключение……….………….…………………………………25
Список использованной литературы…………
array=new TYPE*[sizeRow];
assert(array!=NULL);
for(int i=0; i<sizeRow; i++)
{
array[i]=new TYPE[sizeCol];
assert(array[i]!=NULL);
}
for(i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
array[i][j]=m.array[i][j];
}
}
}
else
{
error(1);
}
}
template<class TYPE>
TMatrix<TYPE>::TMatrix(int row, int col)
{
array=NULL;
sizeRow=0;
sizeCol=0;
if(row>0 && col>0)
{
sizeRow=row;
sizeCol=col;
array=new TYPE*[sizeRow];
assert(array!=NULL);
for(int i=0; i<sizeRow; i++)
{
array[i]=new TYPE[sizeCol];
assert(array[i]!=NULL);
}
}
else
{
error(2);
}
}
template<class TYPE>
TMatrix<TYPE>::~TMatrix()
{
if(array!=NULL)
{
for(int i=0; i<sizeRow; i++)
{
if(array[i]!=NULL)
{
delete [] array[i];
}
}
delete [] array;
}
}
template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator=(
{
if(this!=&m)
{
if(sizeRow==0 && sizeCol==0)
{
sizeRow=m.sizeRow;
sizeCol=m.sizeCol;
array=new TYPE*[sizeRow];
assert(array!=NULL);
for(int i=0; i<sizeRow; i++)
{
array[i]=new TYPE[sizeCol];
assert(array[i]!=NULL);
}
}
if(sizeRow==m.sizeRow && sizeCol==m.sizeCol)
{
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
array[i][j]=m.array[i][j];
}
}
}
else
{
error(3);
}
}
return *this;
}
template<class TYPE>
TYPE & TMatrix<TYPE>::operator()(int row, int col)
{
if(row>0 && row<=sizeRow && col>0 && col<=sizeCol)
{
return array[row-1][col-1];
}
else
{
error(4);
return array[0][0];
}
}
template<class TYPE>
TYPE & TMatrix<TYPE>::operator[](int k)
{
if(sizeRow==1 && k>0 && k<=sizeCol)
{
return array[0][k-1];
}
else
{
if(sizeCol==1 && k>0 && k<=sizeRow)
{
return array[k-1][0];
}
else
{
error(5);
return array[0][0];
}
}
}
template<class TYPE>
int TMatrix<TYPE>::getSizeRow()
{
return sizeRow;
}
template<class TYPE>
int TMatrix<TYPE>::getSizeCol()
{
return sizeCol;
}
template<class TYPE>
void TMatrix<TYPE>::setSize(int row, int col)
{
if(row==0 && col==0)
{
if(array!=NULL)
{
for(int i=0; i<sizeRow; i++)
{
if(array[i]!=NULL)
{
delete [] array[i];
}
}
delete [] array;
array=NULL;
}
sizeRow=0;
sizeCol=0;
return;
}
if(row>0 && col>0)
{
if(array!=NULL)
{
for(int i=0; i<sizeRow; i++)
{
if(array[i]!=NULL)
{
delete [] array[i];
}
}
delete [] array;
}
sizeRow=row;
sizeCol=col;
array=new TYPE*[sizeRow];
assert(array!=NULL);
for(int i=0; i<sizeRow; i++)
{
array[i]=new TYPE[sizeCol];
assert(array[i]!=NULL);
}
}
else
{
error(6);
}
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator+(
{
TMatrix t_m(sizeRow, sizeCol);
if(sizeRow==m.sizeRow&&
{
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
t_m.array[i][j]=array[i][j]+m.
}
}
}
else
{
error(7);
}
return t_m;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator-(
{
TMatrix t_m(sizeRow, sizeCol);
if(sizeRow==m.sizeRow&&
{
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
t_m.array[i][j]=array[i][j]-m.
}
}
}
else
{
error(8);
}
return t_m;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator*(
{
TMatrix t_m(sizeRow, m.sizeCol);
if(sizeCol==m.sizeRow)
{
for(int i=0; i<t_m.sizeRow; i++)
{
for(int j=0; j<t_m.sizeCol; j++)
{
TYPE sum=0;
for(int k=0; k<sizeCol; k++)
{
sum+=array[i][k]*m.array[k][j]
}
t_m.array[i][j]=sum;
}
}
}
else
{
error(9);
}
return t_m;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator^(
{
TMatrix t_m(sizeRow, sizeCol);
if(sizeRow==m.sizeRow&&
{
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
t_m.array[i][j]=array[i][j]*m.
}
}
}
else
{
error(10);
}
return t_m;
}
template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator+=(
{
if(sizeRow==m.sizeRow&&
{
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
array[i][j]+=m.array[i][j];
}
}
}
else
{
error(11);
}
return *this;
}
template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator-=(
{
if(sizeRow==m.sizeRow&&
{
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
array[i][j]-=m.array[i][j];
}
}
}
else
{
error(12);
}
return *this;
}
template<class TYPE>
TMatrix<TYPE> &
TMatrix<TYPE>::operator*=(
{
TMatrix t_m(sizeRow, m.sizeCol);
if(sizeCol==m.sizeRow)
{
for(int i=0; i<t_m.sizeRow; i++)
{
for(int j=0; j<t_m.sizeCol; j++)
{
TYPE sum=0;
for(int k=0; k<sizeCol; k++)
{
sum+=array[i][k]*m.array[k][j]
}
t_m.array[i][j]=sum;
}
}
*this=t_m;
}
else
{
error(29);
}
return *this;
}
template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator^=(
{
if(sizeRow==m.sizeRow&&
{
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
array[i][j]*=m.array[i][j];
}
}
}
else
{
error(13);
}
return *this;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::getTranspose()
{
TMatrix<TYPE> new_m(sizeCol, sizeRow);
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
new_m.array[j][i]=array[i][j];
}
}
return new_m;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator+(TYPE c)
{
TMatrix<TYPE> t_m(*this);
if(sizeRow==sizeCol)
{
for(int i=0; i<sizeRow; i++)
{
t_m.array[i][i]+=c;
}
}
else
{
error(14);
}
return t_m;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator-(TYPE c)
{
TMatrix<TYPE> t_m(*this);
if(sizeRow==sizeCol)
{
for(int i=0; i<sizeRow; i++)
{
t_m.array[i][i]-=c;
}
}
else
{
error(15);
}
return t_m;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator*(TYPE c)
{
TMatrix<TYPE> t_m(sizeRow, sizeCol);
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
t_m.array[i][j]=array[i][j]*c;
}
}
return t_m;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator/(TYPE c)
{
TMatrix<TYPE> t_m(sizeRow, sizeCol);
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
t_m.array[i][j]=array[i][j]/c;
}
}
return t_m;
}
template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator+=(
{
if(sizeRow==sizeCol)
{
for(int i=0; i<sizeRow; i++)
{
array[i][i]+=c;
}
}
else
{
error(16);
}
return *this;
}
template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator-=(
{
if(sizeRow==sizeCol)
{
for(int i=0; i<sizeRow; i++)
{
array[i][i]-=c;
}
}
else
{
error(17);