Спецификация программы: Текст программы:
laba8M.h
class CMetOp
{
public:
CMetOp();
~CMetOp();
double func(CVector X);
double getNorma(CVector &d_Point);
CVector DerivativePoint( CVector d_Point);
double DerivativeDirectionPoint( CVector d_Point );
void Swenn();
void Localization();
void Swenn4();
void GoldenSection2();
void Davidon();
void Daniela();
};
laba8V.h
#include <math.h>
class CVector
{
public:
CVector(int VectorSize);
CVector( const CVector & );
~CVector(void);
int getSize() const;
double getNorma() const;
double & operator[](int subscript);
const double &operator[](int subscript) const;
const CVector & operator=(const CVector &right);
bool operator==( const CVector &right) const;
bool operator!=( const CVector &right) const;
CVector operator*(const double k) const;
double operator*(const CVector &right) const;
CVector operator+(const double &alfaPoint) const;
CVector operator-(const double alfaPoint) const;
CVector operator+(const CVector &right) const;
CVector operator-(const CVector &right) const;
CVector operator-() const;
private:
double vectorPointer[2];
int size;
};
CVector::CVector(int VectorSize)
{
size = VectorSize ;
for( int i = 0; i < size; i++ )
vectorPointer[i]=0;
}
CVector::CVector(const CVector &init) : size(init.size)
{
for( int i = 0; i < size; i++ )
vectorPointer[i]=init.vectorPointer[i];
}
CVector::~CVector(void)
{
}
int CVector::getSize() const
{
return size;
}
double CVector::getNorma() const
{
double result=0;
for (int i=0; i<size; i++)
result+=vectorPointer[i]*vectorPointer[i];
return sqrt(result);
}
double & CVector::operator[](int subscript)
{
return vectorPointer[subscript];
}
const double & CVector::operator[](int subscript) const
{
return vectorPointer[subscript];
}
const CVector & CVector::operator=(const CVector &right)
{
if(&right!=this)
{
if( size!= right.size)
{
size=right.size;
}
for ( int i = 0; i < size; i++)
vectorPointer[i] = right.vectorPointer[i];
}
return *this;
}
bool CVector::operator==( const CVector &right) const
{
if( size != right.size )
return false;
for (int i = 0; i < size; i++)
if ( vectorPointer[i] != right.vectorPointer[i])
return false;
return true;
}
bool CVector::operator!=( const CVector &right) const
{
return ! (*this == right );
}
CVector CVector::operator*(const double k) const
{
CVector result(size);
for (int i=0; i<size;i++)
result[i]=k*vectorPointer[i];
return result;
}
CVector CVector::operator+(const double &alfaPoint) const
{
CVector result(size);
for (int i=0; i<size;i++)
result[i]=vectorPointer[i]+alfaPoint;
return result;
}
CVector CVector::operator-(const double alfaPoint) const
{
return *this+(-alfaPoint);
}
CVector CVector::operator+(const CVector &right) const
{
CVector result(size);
for (int i=0; i<size;i++)
result[i]=vectorPointer[i] + right[i];
return result;
}
double CVector::operator*(const CVector &right) const
{
double result=0;
for (int i=0; i<size;i++)
result+=vectorPointer[i]*right[i];
return result;
}
CVector CVector::operator-(const CVector &right) const
{
CVector result(size);
for (int i=0; i<size;i++)
result[i]=vectorPointer[i] - right[i];
return result;
}
CVector CVector::operator-() const
{
CVector result(size);
for (int i=0; i<size;i++)
result[i]=-vectorPointer[i];
return result;
}
laba8.cpp
// laba8.cpp : Defines the entry point for the console application.
//
#include "laba8V.h"
#include "laba8M.h"
#include <math.h>
#include <iostream.h>
#include <conio.h>
CVector d_left(2);
CVector d_right(2);
CVector X(2);
CVector p(2);
double E = 0.01;
CVector d_r(2);
double d_alpha = 0;
CMetOp :: CMetOp()
{
}
CMetOp :: ~CMetOp()
{
}
double CMetOp :: func(CVector X )
{
double d_Y = 4 * ( X[0] - 5 ) * ( X[0] - 5 ) - ( X[1] - 6 ) * (X[1] - 6);
return d_Y;
}
double CMetOp :: getNorma( CVector &d_Point )
{
return sqrt( d_Point[0] * d_Point[0] + d_Point[1] * d_Point[1] );
}
CVector CMetOp :: DerivativePoint( CVector d_Point)
{
int i;
double d_pace = 0.000001;
CVector d_Orta(2);
CVector d_resault(2);
d_Orta[0] = d_Orta [1] = 0;
for( i=0; i<2; i++ )
{
d_Orta[i] = 1;
double a = func ( d_Point + d_Orta * d_pace );
double b = func ( d_Point - d_Orta * d_pace );
d_resault[i] = ( a - b ) / ( 2* d_pace );
d_Orta[i] = 0;
}
return d_resault;
}
double CMetOp :: DerivativeDirectionPoint( CVector d_Point )
{
CVector d_resault(2);
double d_res = 0;
CVector d_p(2);
for ( int i=0; i<2; i++ )
d_p[i] = p[i] / getNorma(p);
d_resault = DerivativePoint(d_Point);
for (int i=0; i<2; i++ )
d_res += d_resault[i] * p[i];
return d_res;
}
void CMetOp :: Swenn()
{
double d_step = 0.01;
CVector d_startPoint(2), d_nextPoint(2), d_previousPoint(2);
d_left = d_right = 0;
d_startPoint = X;
d_nextPoint = d_startPoint;
int k = 0;
d_nextPoint = d_startPoint + p * d_step;
if ( DerivativeDirectionPoint( X ) > 0 )
d_step = -d_step;
d_nextPoint = d_startPoint + p *d_step;
while ( DerivativeDirectionPoint( d_previousPoint ) * DerivativeDirectionPoint( d_nextPoint ) > 0 )
{
d_step = d_step * 2;
d_previousPoint = d_startPoint;
d_startPoint = d_nextPoint;
d_nextPoint = d_nextPoint + p *d_step;
}
d_left = d_previousPoint;
d_right = d_nextPoint;
}
void CMetOp :: Localization()
{
CVector d_bufPoint(2);
int i, k = 0;
d_bufPoint = d_right - d_left;
CVector d_alfaPoint(2), d_muPoint(2);
while ( ( getNorma( d_bufPoint ) > E ))
{
for ( i=0; i<2; i++ )
{
d_alfaPoint[i] = d_left[i] + ( d_right[i] - d_left[i] ) / 4;
d_muPoint[i] = d_right[i] - ( d_right[i] - d_left[i] ) / 4;
}
if( func(d_alfaPoint) < func(d_muPoint) )
d_right = d_muPoint;
else
d_left = d_alfaPoint;
k++;
d_bufPoint = d_right - d_left;
}
CVector Xmin(2);
for ( i=0; i<2; i++ )
Xmin[i] = ( d_left[i] + d_right[i] )/2;
cout<<"("<<Xmin[0]<<";"<<Xmin[1]<<")"<<endl;
}
void CMetOp :: Swenn4()
{
double d_alfa = 0.01;
CVector d_p(2);
CVector d_startPoint(2);
CVector d_nextPoint(2), d_previousPoint(2);
d_left = d_right = 0;
d_startPoint = X;
d_nextPoint = d_startPoint;
d_previousPoint = d_startPoint;
d_p = - DerivativePoint( X );
if (DerivativeDirectionPoint( X ) > 0 )
d_p = -d_p;
while(DerivativeDirectionPoint( d_previousPoint ) * DerivativeDirectionPoint( d_nextPoint ) > 0 )
{
d_previousPoint = d_startPoint;
d_nextPoint = d_startPoint + d_p * d_alfa;
d_startPoint = d_nextPoint;
d_alfa *= 2;
}
d_left = d_previousPoint;
d_right = d_nextPoint;
}
void CMetOp :: GoldenSection2()
{
Swenn4();
int i, k=1;
CVector d_bufPoint(2), d_p(2);
CVector d_alfaPoint(2), d_muPoint(2);
d_bufPoint = d_right - d_left;
for ( i = 0; i < 2; i++ )
d_p [i] = p[i] / getNorma( p );
for ( i = 0; i < 2; i++ )
d_alfaPoint[i] = d_left[i] + 0.618 * getNorma(d_bufPoint) * d_p [i] ;
do
{
d_muPoint = d_left + d_right - d_alfaPoint;
if ( d_alfaPoint[0] < d_muPoint[0] )
{
if (( func( d_alfaPoint ) < func( d_muPoint )))
{
d_right = d_muPoint;
}
else
{
d_left = d_alfaPoint;
d_alfaPoint = d_muPoint;
}
}
else
{
if (( func( d_alfaPoint ) < func( d_muPoint )))
d_left = d_muPoint;
else
{
d_right = d_alfaPoint;
d_alfaPoint = d_muPoint;
}
}
d_bufPoint = d_right - d_left;
k++;
}
while(getNorma( d_bufPoint ) > E);
}
void CMetOp :: Davidon()
{
int i, k=1;
CVector d_bufPoint(2);
Swenn4();
CVector d_stepDavidion(2) ;
double d_z, d_W, d_gamma;
do
{
d_bufPoint = d_right - d_left;
d_z = DerivativeDirectionPoint( d_left ) + DerivativeDirectionPoint( d_right ) + (3 * ( func ( d_left ) - func( d_right ) )) / getNorma( d_bufPoint );
d_W = sqrt( (d_z * d_z - DerivativeDirectionPoint( d_left ) * DerivativeDirectionPoint( d_right )));
d_gamma = ( d_z - DerivativeDirectionPoint( d_left ) + d_W ) / ( DerivativeDirectionPoint( d_right ) - DerivativeDirectionPoint( d_left ) + 2 * d_W );
for ( i=0; i<2; i++ )
{
d_stepDavidion[i] = d_left[i] + d_gamma * ( (d_right[i] - d_left[i]) );
d_r[i] = d_stepDavidion[i];
}
if ( k != 1 )
d_r = d_left + d_stepDavidion * p;
if (DerivativeDirectionPoint( d_r ) > 0)
for ( i=0; i<2; i++ )
d_left[i] = d_r[i];
else
for ( i=0; i<2; i++ )
d_right[i] = d_r[i];
k++;
}while((DerivativeDirectionPoint( d_r )) > E);
d_alpha = ( d_r[0] + d_r[1] ) / 2;
}
void CMetOp :: Daniela()
{
int i_Num;
int k = 1;
double d_b;
double d_E = 0.28;
CVector XMin(2);
CVector XBuff(2);
cout<<"1 - ZS2"<<endl<<"2 - Davidon"<<endl;
cin>>i_Num;
do
{
if(i_Num == 2)
{ XBuff = X;
do
{
if ( k == 1)
{
p = - DerivativePoint( X );
Davidon();
X = X + p * d_alpha ;
XMin = X;
}
else
{
double d_beta = (DerivativePoint( X ) * ( DerivativePoint( X ) - DerivativePoint( XBuff ) )) / ( p * ( DerivativePoint( X ) - DerivativePoint( XBuff ) ));
p = - DerivativePoint( X ) + p * d_beta;
Davidon();
XBuff = X;
X = X + p * d_alpha;
XMin = X;
}
k++;
d_b = getNorma(DerivativePoint( XMin ));
}
while (( d_b > d_E )) ;
break;
}
else
{
XBuff = X;
do
{
if ( k == 1)
{
p = - DerivativePoint( X );
GoldenSection2();
X = X + p * d_alpha ;
XMin = X;
}
else
{
double d_beta = (DerivativePoint( X ) * ( DerivativePoint( X ) - DerivativePoint( XBuff ) )) / ( p * ( DerivativePoint( X ) - DerivativePoint( XBuff ) ));
p = - DerivativePoint( X ) + p * d_beta;
GoldenSection2();
XBuff = X;
X = X + p * d_alpha;
XMin = X;
}
k++;
d_b = getNorma(DerivativePoint( XMin ));
}
while (( d_b > d_E )) ;
break;
}
}while(1);
}
void main()
{
CMetOp method;
X[0] = 0;
X[1] = 0;
method.Daniela();
getch();
}