Все лабораторные работы / Всё стасовское новое / prog / laba8

// 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 :: refresh()
{
	X[0] = 5;
  X[1] = 6;
  Swenn4();
  Localization();
}

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 )) ;
			refresh();
			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 )) ;
		refresh();
		break;
	}

	}while(1);

}

void main()
{
	CMetOp method;
	X[0] = 0;
	X[1] = 0;
	method.Daniela();
  getch();
}