import Method;

/*
 *
 * Bayes1
 *
 */
class Bayes1 extends Method
{
	static private final int NOT_SEC_POINT = 0;
	static private final int SEC_POINT = 1;
	static private final int PAR1 = 10;
	static private final int PAR2 = 50;
	static private final double VAL = 1e-6;
	private double COEF;
	private double RMAX;
	//Parameters to function

	private int ix;

	//Internal variables
	private double x2[];
	private double mz[];

	public Bayes1( Output output, Parameters p, Results r, double fm[], double xn[][] )
	{
		super( output, p, r, fm, xn );
		COEF = 100*1e-16;
		RMAX = 0.5*r1mach(2);
	}

	public void run()
	{
		glbayes0(x, a, b, n, it, lt, fm, xn);
		finish();
	}

	private void glbayes0(double x[], double a[], double b[], int n, int it, int lt, double fm[], double xn[][])
	{
		int nn = n;
		double z[] = new double[nn];
		x2 = new double[nn];
		mz = new double[nn];
		ff = r1mach(2);
		best_iteration = 0;
		copy_array( z, x, nn );
		ix = NOT_SEC_POINT;
		for (int iteration = 0; iteration < lt; iteration++)
		{
			lp_point(z, a, b, nn, iteration);
			fm[iteration] = Task.f(z,nn);

			r.iteration = iteration;
			if ( iteration == 0 ) r.y = fm[0];
			copy_array(xn[iteration], z, nn);
			if (fm[iteration] < ff)
			{
				ff = fm[iteration];
				best_iteration = iteration;

				r.y = ff;
				copy_array ( r.x, xn [best_iteration], nn);

			}
			output.met_out(iteration + 1);
		}
		for (int iteration = lt; iteration < it; iteration++)
		{
			mig2f2 (z, a, b, nn, xn, x2, mz, fm, ff, iteration);
			fm [iteration] = Task.f(z,n);

			r.iteration = iteration;
			if ( iteration == 0 ) r.y = fm[0];
			copy_array (xn[iteration], z, nn);
			if (fm[iteration] < ff)
			{
				ff = fm[iteration];
				best_iteration = iteration;

				r.y = ff;
				copy_array ( r.x, xn [best_iteration], nn);
			}
			output.met_out(iteration + 1);
		}

	}

	private void mig2f2(double x[], double a[], double b[], int nn,
	double xn[][], double x2[], double z[], double fm[], double ff, int m)
	{
		int k, k2;
		double f2;
		double fmin = 0.;

		k2 = Math.min(PAR2, Math.max(PAR1, m)) * nn;
		if (ix == NOT_SEC_POINT)
		{
			random_point(x2, a, b, nn);
			k2--;
			ix = SEC_POINT;
		}
		f2 = fiap1(x2, nn, xn, fmin, fm, ff, m);

		double fi;
		double ffm = 0;
		for (k = 0; k < k2; k++)
		{
			random_point(z, a, b, nn);
			fi = fiap1(z, nn, xn, fmin, fm, ff, m);
			if (k == 0)
			{
				if (fi >= f2)
				{
					copy_array(x, x2, nn);
					copy_array(x2, z, nn);
					ffm  = f2;
					fmin = f2 = fi;
				}
				else
				{
					copy_array(x, z, nn);
					ffm  = fi;
					fmin = f2;
				}
			}
			else
			{
				if (fi < f2)
				{
					if (fi < ffm)
					{
						copy_array(x2, x, nn);
						copy_array(x, z, nn);
						fmin = f2 = ffm;
						ffm  = fi;
					}
					else
					{
						copy_array(x2, z, nn);
						fmin = f2 = fi;
					}
				}
			}
		}
	}

	private double fiap1(double x[], int nn, double xn[][], double fmin, double fm[], double ff, int m)
	{
		double yk, fii;
		int j;
		double dd;
		double d;
		double pp;

		yk  = ff - Math.max (VAL, COEF * Math.abs (ff));
		fii = Math.min (RMAX, RMAX / (fm[0] - yk));
		for (j = 0; j < m; j++)
		{
			dd = distance (xn [j], x, nn);
			d  = dd*dd;
			pp = fm [j] - yk;

			if (d < Math.min(RMAX, pp * fii))
			{
				fii = d / pp;
				if (fii <= -fmin) return (-fii);
			}
		}
		return (-fii);
	}



}