C++ (Cpp) rosenbrock Examples

Example #1

File: F13.cpp Project: mikeagn/CEC2010SS-LSGO-Benchmarks-CPP

double F13::compute(vector<double> x){
	int i,k;
	double result=0.0;

	if(Ovector==NULL)
	{
		Ovector=createShiftVector(dimension,minX,maxX-1);
		Pvector=createPermVector(dimension);
	}

	for(i=0;i<dimension;i++)
	{
		anotherz[i]=x[i]-Ovector[i];
	}

	for(k=1;k<=dimension/(2*nonSeparableGroupSize);k++)
	{
		result+=rosenbrock(anotherz,nonSeparableGroupSize,k);
	}

//	printf("Rosenbrock = %1.16E\n", result);
//	printf("Sphere = %1.16E\n", sphere(anotherz, dimension, 2));

	result+=sphere(anotherz, dimension, 2);
	return(result);
}

Example #2

File: opt_func.c Project: btbytes/ci

/************************************************************
*     Function:
*
*   Parameters:
*
*      Returns:
*
*  Description:
*
*************************************************************/
double OPT_Function_Routines (int fun_idx,int dim, double *para)
{
    double result;
    switch (fun_idx)
    {
        case F6:
          result = f6(para);
          break;
        case SPHERE:
          result = sphere(dim,para);
          break;
        case ROSENBROCK:
          result = rosenbrock(dim,para);
          break;
        case RASTRIGRIN:
          result = rastrigrin(dim,para);
          break;
        case GRIEWANK:
          result = griewank(dim,para);
          break;
        default:
          break;
    }

    return(result);
}

Example #3

File: F8.cpp Project: mikeagn/CEC2010SS-LSGO-Benchmarks-CPP

double F8::compute(double* x){
	int    m = nonSeparableGroupSize;
	int    i;
	double result;

	if(Ovector == NULL) {
		Ovector = createShiftVector(dimension,minX,maxX-1);

//		printf("\n\n\nO vector\n\n\n");
//		for (i = 0; i<dimension; i++){
//			printf("%f\t",Ovector[i]);
//		}

		Pvector = createPermVector(dimension);
		
//TODO: Neeed to change back to random one ****************************************************************************
//		Pvector = (int*)malloc(sizeof(int) * dimension);
//		for (i = 0; i<dimension; i++){
//			Pvector[i] = i;	
//		}

		/*
		printf("\n\n\nP vector\n\n\n");
		for (i = 0; i<dimension; i++){
			printf("%d\t",Pvector[i]);
		}
		*/
	}

	for(i = 0; i < dimension; i++) {
		anotherz[i] = x[i] - Ovector[i];
	}

	for(i = 0; i < m; i++) {
		anotherz1[i] = anotherz[Pvector[i]];
	}

	for(i = m; i < dimension; i++) {
		anotherz2[i - m] = anotherz[Pvector[i]];
	}

//	printf("\n\n\nanotherz1\n\n\n");
//	for (i = 0; i<m; i++){
//		printf("%f\t",anotherz1[i]);
//	}

	result = rosenbrock(anotherz1,m) * 1e6 + sphere(anotherz2,dimension - m);

//	printf("Rosenbrock Part = %1.16E\n", rosenbrock(anotherz1,m) * 1e6);
//	printf("Sphere Part = %1.16E\n", sphere(anotherz2,dimension - m));

	return(result);
}

Example #4

File: quasinewton_test.c Project: shishougang/liquid-dsp

// my utility function
float myutility(float * _x, unsigned int _n)
{
#if 0
    float u = 1.0f;
    unsigned int i;
    for (i=0; i<_n; i++) {
        float di = _x[i] - 1.0f;
        float ui = expf(-di*di);
        u *= ui;
    }

    return 1.0f - u;
#else
    return rosenbrock(NULL, _x, _n);
#endif
}

Example #5

File: F20.cpp Project: lsgo-metaheuristics/CCAS

	double F20::compute(vector<double> x){
		int i;
		double result = 0.0;

		if (Ovector == NULL)
		{
			Ovector = createShiftVector(dimension, minX, maxX - 1);
		}

		for (i = 0; i < dimension; i++)
		{
			anotherz[i] = x[i] - Ovector[i];
		}

		result = rosenbrock(anotherz, dimension);
		return(result);
	}

Example #6

File: ex1_fminsearch.c Project: dsimba/optimc

int main(void) {
	int N, i, retval;
	double *xi, *xf;

	custom_function quartic_min = {quartic, 0};
	custom_function rosenbrock_min = {rosenbrock, 0};

	N = 4;

	xi = (double*)malloc(sizeof(double)* N);
	xf = (double*)malloc(sizeof(double)* N);

	xi[0] = 3; xi[1] = -1; xi[2] = 0; xi[3] = -1;


	retval = fminsearch(&quartic_min, N, xi, xf);

	printf("Powell's Quartic Function \n");
	printf("Return Value %d \nObjective Function %g \n", retval, quartic(xf, N,0));

	printf("Function minimized at : ");
	for (i = 0; i < N; ++i) {
		printf("%g ", xf[i]);
	}
	printf("\n \n");
	free(xi);
	free(xf);
	printf("\nRosenbrock Function \n");
	N = 2;
	xi = (double*)malloc(sizeof(double)* N);
	xf = (double*)malloc(sizeof(double)* N);

	xi[0] = -1.2; xi[1] = 1;
	retval = fminsearch(&rosenbrock_min, N, xi, xf);

	printf("Return Value %d \nObjective Function %g \n", retval, rosenbrock(xf, N,0));

	printf("Function minimized at : ");
	for (i = 0; i < N; ++i) {
		printf("%g ", xf[i]);
	}


	return 0;
}

Example #7

File: sfunc_rosenbrock.cpp Project: barak/adolc

/*                                                   The interface function */
double originalScalarFunction( double* indeps ) {
    return rosenbrock(indepDim, indeps);
}