/* Compute both f and df together. */
void
my_fdf (const gsl_vector *x, void *params,
double *f, gsl_vector *df)
{
*f = my_f(x, params);
my_df(x, params, df);
}
int main()
{
// side-effect in ?:
glob=0;
result=glob?1:my_f();
assert(result==0);
// side-effect in ||
glob=0;
result=glob||my_f();
assert(result==0);
// side-effect deep down
glob=0;
result=glob||(0+my_f());
assert(result==0);
// another variant of this
int r, c=1;
r=c?(c=0, 10):20;
assert(c==0 && r==10);
}
#include<iostream> int my_f(int); //const int c4 = my_f(4); int c4 = my_f(4); //const int c5 = my_f(5); //const int c5 = my_f(5);
int main()
{
#ifdef _WIN32
// Visual Studio won't even parse most of these
#else
// a side effect inside an array type
x=1;
int array[++x];
assert(x==2);
assert(sizeof(array)==sizeof(int)*2);
// same with typedef
x=1;
typedef int array_type[++x];
assert(x==2);
assert(sizeof(array_type)==sizeof(int)*2);
// a side effect inside an initializer
x=1;
int local=++x, local2=x;
assert(x==2);
assert(local==2);
assert(local2==2);
// a side effect inside a function argument list
x=1;
int return_value=my_f(++x);
assert(x==2);
assert(return_value==2);
// using a pointer
x=1;
int *p=&x;
y=++(*p);
assert(y==2);
assert(x==2);
// in a struct
x=1;
struct struct_type
{
int a[++x];
int b;
};
assert(x==2);
assert(sizeof(struct struct_type)==sizeof(int)*2+sizeof(int));
// this is evaluated when the type is defined, not later
x++;
assert(sizeof(struct struct_type)==sizeof(int)*2+sizeof(int));
// only happens once
x=1;
y=1;
struct other_struct
{
int a[++x];
} v1[y++], v2[y++], v3[y++];
assert(x==2);
assert(y==4);
assert(sizeof(v1)==sizeof(int)*2*1);
assert(sizeof(v2)==sizeof(int)*2*2);
assert(sizeof(v3)==sizeof(int)*2*3);
// inside a typecast (struct)
x=1;
(struct { int a[x++]; } *)0;
assert(x==2);
// inside a typecast (function pointer)
x=1;
(int (*)(int a[x++]))0; // This is ignored by gcc! Haha!
assert(x==1);
// inside sizeof
x=1;
assert(sizeof(struct { int a[x++]; })==sizeof(int));
assert(x==2);
// multi-dimensional
x=y=1;
typedef int my_array1[x][y];
x++;
assert(sizeof(my_array1)==sizeof(int));
#endif
}
int m2()
{
return my_f();
}
void minimd(density_t * ndft){
int status;
int i;
double stepmin, minimum, g_initial;
char * output_string;
gsl_vector *ss;
const gsl_multimin_fminimizer_type *T;
gsl_multimin_fminimizer *s;
gsl_multimin_function my_func;
size_t iter;
params_gsl_multimin_function_t params;
switch(gradient_free_mode){
case SIMPLEX :
output_string = (char *) malloc(25*sizeof(char));
params.nDFT = density_get_val(ndft);
my_func.n = ipf.npar;
my_func.f = my_f;
my_func.params = (void *) (¶ms);
/* Initial step sizes */
ss = gsl_vector_alloc (ipf.npar);
gsl_vector_set_all(ss, 0.1);
/* We use the Simplex algorithm from thee GNU Scientific Library (GSL)
in its optimized version nmsimplex2 */
T = gsl_multimin_fminimizer_nmsimplex2;
messages_basic("\n\n\nStarting the optimization.\n\n\n");
g_initial = my_f(ipf.gamma, ¶ms);
if(g_initial < epsilon_gvalue){
if(myid == 0) printf("The value of G for the starting gamma is %.12lg,\n", g_initial);
if(myid == 0) printf("which is already below the requested threshold of %.12lg\n", epsilon_gvalue);
parallel_end(EXIT_SUCCESS);
}
if(myid == 0) printf(" Starting from gamma = ");
if(myid == 0) {for(i = 0; i < ipf.npar; i++) printf ("%.5f ", gsl_vector_get (ipf.gamma, i));}
if(myid == 0) printf("\n G(gamma) = %.12lg\n", g_initial);
/* Initialization of the minimizer s for the function
my_func starting at the x point */
messages_basic("\n\nInitialization of the minimizer.\n\n\n");
s = gsl_multimin_fminimizer_alloc (T, ipf.npar);
gsl_multimin_fminimizer_set (s, &my_func, ipf.gamma, ss);
minimum = g_initial;
iter = 0;
do
{
iter++;
if(myid == 0) printf(" Iter = %d\n", (int)iter);
if(myid == 0) printf(" gamma = ");
if(myid == 0) {for(i = 0; i < ipf.npar; i++) printf ("%.5f ", gsl_vector_get (gsl_multimin_fminimizer_x(s), i));}
if(myid == 0) printf("\n starting G(gamma) = %15.10lg\n", minimum);
/* We make an iteration of the minimizer s */
status = gsl_multimin_fminimizer_iterate (s);
minimum = gsl_multimin_fminimizer_minimum(s);
if (status){
if(myid == 0) printf(" Breaking. Reason: %s\n", gsl_strerror(status));
break;
}
if(myid == 0) printf(" G(gamma) = %15.10f\n", minimum);
stepmin = gsl_multimin_fminimizer_size (s);
status = gsl_multimin_test_size (stepmin, 1e-2);
}
while (status == GSL_CONTINUE && iter < 100);
if(myid == 0) printf("\n\nFinished optimization. status = %d (%s)\n", status, gsl_strerror(status));
if(myid == 0) printf(" Final gamma = ");
if(myid == 0) {for(i = 0; i < ipf.npar; i++) printf ("%.5f ", gsl_vector_get (gsl_multimin_fminimizer_x(s), i));}
if(myid == 0) printf("\n With value: G(gamma) = %.12lg\n\n", gsl_multimin_fminimizer_minimum(s));
gsl_vector_memcpy(ipf.gamma, gsl_multimin_fminimizer_x(s));
sprintf(output_string, "pot");
ipf_write(ipf, ipf_ref, output_string);
gsl_multimin_fminimizer_free (s);
fflush(stdout);
gsl_vector_free(ss);
break;
case GENETIC_ALGORITHM :
output_string = (char *) malloc(75*sizeof(char));
sprintf(output_string, "python ga.py %f %f %f %f %f %f %d %d %d",
grid.l, grid.step, extpot.alpha, extpot.Lmin, extpot.Lmax,
extpot.delta, extpot.npotex, ipf.npar, ipf.poten_selector);
system(output_string);
free(output_string);
break;
}
}
#include<iostream>
int g =11;
//extern const int c4;
//extern const int c5;
int my_f(int c){
int res = c*g;
g = g*2;
return res;
}
const int c1 = 1;
const int c2 = my_f(2);
const int c3 = my_f(3);
//extern const int c4;
extern int c4;
int main(){
std::cout<<"c1="<<c1<<"\n";
std::cout<<"c2="<<c2<<"\n";
std::cout<<"c3="<<c3<<"\n";
std::cout<<"c4="<<c4<<"\n";
return 0;
}
