Автор работы: Пользователь скрыл имя, 30 Ноября 2013 в 13:35, курсовая работа
В настоящее время не существует методов, которые в одинаковой мере были бы хороши для всех систем ЛАУ. Почти все методы являются ориентированными и учитывают тем или иным образом специальные свойства матриц систем ЛАУ.
В курсовом проекте я рассматриваю метод скорейшего спуска. Этот метод не входит в число методов, которые широко используются и часто встречаются в литературе. Он реже используется в практике вычислений, но тем не менее содержит глубокие идеи и входит в основы теории вычислительной алгебры.
Введение………………………………………………………...2
1. Метод градиента (метод скорейшего спуска) для случая системы нелинейных уравнений……………………….……….3
2. Метод скорейшего спуска для случая системы линейных уравнений…………………………………………………………..11
3. Свойства приближений метода скорейшего спуска……17
Заключение……….………….…………………………………25
Список использованной литературы…………
}
return *this;
}
template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator*=(
{
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
array[i][j]*=c;
}
}
return *this;
}
template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator/=(
{
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
array[i][j]/=c;
}
}
return *this;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::getRow(int row)
{
TMatrix<TYPE> t_m(1, sizeCol);
if(row>0 && row<=sizeRow)
{
for(int i=0; i<sizeCol; i++)
{
t_m.array[0][i]=array[row-1][
}
}
else
{
error(18);
}
return t_m;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::getCol(int col)
{
TMatrix<TYPE> t_m(sizeRow, 1);
if(col>0 && col<=sizeCol)
{
for(int i=0; i<sizeRow; i++)
{
t_m.array[i][0]=array[i][col-
}
}
else
{
error(19);
}
return t_m;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::getPart(int i1, int j1, int m, int n)
{
TMatrix<TYPE> res(m,n);
if(i1>0 && i1<=sizeRow && j1>0 && j1<=sizeCol &&
m>0 && i1+m<=sizeRow+1 && n>0 && j1+n<=sizeCol+1)
{
for(int i=0, i2=i1-1; i<m; i++, i2++)
{
for(int j=0, j2=j1-1; j<n; j++, j2++)
{
res.array[i][j]=array[i2][j2];
}
}
}
else
{
error(20);
}
return res;
}
template<class TYPE>
void TMatrix<TYPE>::setPart(int i1, int j1, TMatrix<TYPE> &t)
{
int m=t.getSizeRow(), n=t.getSizeCol();
if(i1>0 && i1<=sizeRow && j1>0 && j1<=sizeCol &&
m>0 && i1+m<=sizeRow+1 && n>0 && j1+n<=sizeCol+1)
{
for(int i=0, i2=i1-1; i<m; i++, i2++)
{
for(int j=0, j2=j1-1; j<n; j++, j2++)
{
array[i2][j2]=t.array[i][j];
}
}
}
else
{
error(21);
}
}
template<class TYPE>
void TMatrix<TYPE>::swapRow(int i1, int i2)
{
if(i1>0 && i1<=sizeRow && i2>0 && i2<=sizeRow)
{
for(int j=0; j<sizeCol; j++)
{
TYPE t=array[i1-1][j];
array[i1-1][j]=array[i2-1][j];
array[i2-1][j]=t;
}
}
else
{
error(22);
}
}
template<class TYPE>
void TMatrix<TYPE>::swapCol(int j1, int j2)
{
if(j1>0 && j1<=sizeCol && j2>0 && j2<=sizeCol)
{
for(int i=0; i<sizeRow; i++)
{
TYPE t=array[i][j1-1];
array[i][j1-1]=array[i][j2-1];
array[i][j2-1]=t;
}
}
else
{
error(23);
}
}
template<class TYPE>
TMatrix<TYPE> operator+(TYPE c, TMatrix<TYPE> &m)
{
return m+c;
}
template<class TYPE>
TMatrix<TYPE> operator-(TYPE c, TMatrix<TYPE> &m)
{
return m*(-1)+c;
}
template<class TYPE>
TMatrix<TYPE> operator*(TYPE c, TMatrix<TYPE> &m)
{
return m*c;
}
template<class TYPE>
void TMatrix<TYPE>::setRow(int row_index, TMatrix<TYPE> &m)
{
if(m.sizeRow==1 && sizeCol==m.sizeCol &&
row_index>0 && row_index<=sizeRow)
{
for(int i=0; i<sizeCol; i++)
{
array[row_index-1][i]=m.array[
}
}
else
{
error(24);
}
}
template<class TYPE>
void TMatrix<TYPE>::setCol(int col_index, TMatrix<TYPE> &m)
{
if(sizeRow==m.sizeRow && m.sizeCol==1 &&
col_index>0 && col_index<=sizeCol)
{
for(int i=0; i<sizeRow; i++)
{
array[i][col_index-1]=m.array[
}
}
else
{
error(25);
}
}
template<class TYPE>
TYPE TMatrix<TYPE>::operator%(
{
TYPE sum=0;
if(sizeRow==m.sizeRow && sizeCol==m.sizeCol)
{
if(sizeRow==1)
{
for(int i=0; i<sizeCol; i++)
{
sum+=array[0][i]*m.array[0][i]
}
}
else
{
if(sizeCol==1)
{
for(int i=0; i<sizeRow; i++)
{
sum+=array[i][0]*m.array[i][0]
}
}
else
{
error(26);
}
}
}
else
{
if(sizeRow==m.sizeCol && sizeCol==m.sizeRow)
{
if(sizeRow==1)
{
for(int i=0; i<sizeCol; i++)
{
sum+=array[0][i]*m.array[i][0]
}
}
else
{
if(sizeCol==1)
{
for(int i=0; i<sizeRow; i++)
{
sum+=array[i][0]*m.array[0][i]
}
}
else
{
error(27);
}
}
}
}
return sum;
}
template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator-()
{
return (*this)*(-1);
}
template<class TYPE>
TMatrix<TYPE> & TMatrix<TYPE>::setSingle(int n)
{
if(n>0)
{
setSize(n,n);
init(0);
for(int i=0; i<n; i++)
{
array[i][i]=1;
}
}
else
{
error(28);
}
return *this;
}
template<class TYPE>
istream & operator>>(istream &in, TMatrix<TYPE> &m)
{
m.readSize(in);
m.readArray(in);
return in;
}
template<class TYPE>
ostream & operator<<(ostream &out, TMatrix<TYPE> &m)
{
m.writeSize(out);
m.writeArray(out);
return out;
}
template<class TYPE>
void TMatrix<TYPE>::init(TYPE c)
{
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
array[i][j]=c;
}
}
}
template<class TYPE>
void TMatrix<TYPE>::initStat(TYPE *p, int size_r, int size_c)
{
this->setSize(size_r,size_c);
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
array[i][j]=p[i*size_c+j];
}
}
}
template<class TYPE>
void TMatrix<TYPE>::initDynam(TYPE **p, int size_r, int size_c)
{
this->setSize(size_r,size_c);
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
array[i][j]=p[i][j];
}
}
}
template<class TYPE>
int TMatrix<TYPE>::readSize(
{
if(!in)
{
return 0;
}
int size1, size2;
in>>size1>>size2;
setSize(size1, size2);
return 1;
}
template<class TYPE>
int TMatrix<TYPE>::readArray(
{
if(!in)
{
return 0;
}
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
in>>array[i][j];
}
}
return 1;
}
template<class TYPE>
int TMatrix<TYPE>::writeSize(
{
if(!out)
{
return 0;
}
out<<sizeRow<<' '<<sizeCol<<endl;
return 1;
}
template<class TYPE>
int TMatrix<TYPE>::writeArray(
{
if(!out)
{
return 0;
}
for(int i=0; i<sizeRow; i++)
{
for(int j=0; j<sizeCol; j++)
{
out.width(14);
out<<array[i][j];
}
out<<endl;
}
return 1;
}
template<class TYPE>
void TMatrix<TYPE>::error(int error_id)
{
cout<<"TMatrix ERROR: #"<<error_id<<endl;
}#endif
Приложение 3.
Результат работы программы.
Решение систем линейных алгебраических уравнений
Метод наискорейшего спуска
1 - Ввести данные из файла
2 - Ввести погрешность вычислений
3 - Ввести максимальное кол-во шагов
4 - Решить СЛАУ
Esc - Выход
Введите имя файла:
a.txt
0.330000 -1.120000 -1.080000 1.140000 0.300000
-1.120000 4.330000 0.240000 -1.220000 0.500000
-1.080000 0.240000 7.210000 -3.220000 0.700000
1.140000 -1.220000 -3.220000 5.430000 0.900000
Введите погрешность вычислений (1.000000e-07): 0.01
Введите максимальное кол-во шагов (10000): 10000
Решение СЛАУ
Расширенная матрица системы:
0.330000 -1.120000 -1.080000 1.140000 0.300000
-1.120000 4.330000 0.240000 -1.220000 0.500000
-1.080000 0.240000 7.210000 -3.220000 0.700000
1.140000 -1.220000 -3.220000 5.430000 0.900000
Максимальное кол-во шагов: 10000
Число шагов: 7456
Решение:
-2.660921
-0.395151
-0.007408
0.633289
1 Демидович Б.П. , Марон И.А. “Основы вычислительной математики”
2 Демидович Б.П. , Марон И.А. “Основы вычислительной математики”
3 Крылов В.И., Бобков В.В., Монастырный П.И. “Начала теории вычислительных методов. Линейная алгебра и нелинейные уравнения” .