算法专栏 - vfdff的博客

vfdff(作者)

2010-08-08 00:12

1

/*这是一个非常简单的遗传算法源代码， 
是由Denis Cormier (North Carolina State University)开发的， 
Sita S.Raghavan (University of North Carolina at Charlotte)修正。 
代码保证尽可能少，实际上也不必查错。对一特定的应用修正此代码， 
用户只需改变常数的定义并且定义“评价函数”即可。 
注意代码的设计是求最大值，其中的目标函数只能取正值； 
且函数值和个体的适应值之间没有区别。 
该系统使用比率选择、精华模型、单点杂交和均匀变异。 
如果用Gaussian变异替换均匀变异，可能得到更好的效果。 
代码没有任何图形，甚至也没有屏幕输出， 
主要是保证在平台之间的高可移植性。读者可以从ftp.uncc.edu, 
目录 coe/evol中的文件prog.c中获得。要求输入的文件应该命名为‘gadata.txt’； 
系统产生的输出文件为‘galog.txt’。输入的文件由几行组成：数目对应于变量数。 
且每一行提供次序——对应于变量的上下界。如第一行为第一个变量提供上下界， 
第二行为第二个变量提供上下界，等等。*/ 
 
/**************************************************************************/ 
/* This is a simple genetic algorithm implementation where the */ 
/* evaluation function takes positive values only and the      */ 
/* fitness of an individual is the same as the value of the    */ 
/* objective function                                          */ 
/**************************************************************************/ 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <math.h> 
 
/* Change any of these parameters to match your needs */ 
 
#define POPSIZE 50               /* population size */ 
#define MAXGENS 1000             /* max. number of generations */ 
#define NVARS 3                  /* no. of problem variables */ 
#define PXOVER 0.8               /* probability of crossover */ 
#define PMUTATION 0.15           /* probability of mutation */ 
#define TRUE 1 
#define FALSE 0 
 
int generation;                  /* current generation no. */ 
int cur_best;                    /* best individual */ 
FILE *galog;                     /* an output file */ 
 
struct genotype /* genotype (GT), a member of the population */ 
{ 
  double gene[NVARS];        /* a string of variables */ 
  double fitness;            /* GT's fitness */ 
  double upper[NVARS];       /* GT's variables upper bound */ 
  double lower[NVARS];       /* GT's variables lower bound */ 
  double rfitness;           /* relative fitness */ 
  double cfitness;           /* cumulative fitness */ 
}; 
 
struct genotype population[POPSIZE+1];    /* population */ 
struct genotype newpopulation[POPSIZE+1]; /* new population; */ 
                                          /* replaces the */ 
                                          /* old generation */ 
 
/* Declaration of procedures used by this genetic algorithm */ 
 
void initialize(void); 
double randval(double, double); 
void evaluate(void); 
void keep_the_best(void); 
void elitist(void); 
void select(void); 
void crossover(void); 
void Xover(int,int); 
void swap(double *, double *); 
void mutate(void); 
void report(void); 
 
/***************************************************************/ 
/* Initialization function: Initializes the values of genes    */ 
/* within the variables bounds. It also initializes (to zero)  */ 
/* all fitness values for each member of the population. It    */ 
/* reads upper and lower bounds of each variable from the      */ 
/* input file `gadata.txt'. It randomly generates values       */ 
/* between these bounds for each gene of each genotype in the  */ 
/* population. The format of the input file `gadata.txt' is    */ 
/* var1_lower_bound var1_upper bound                           */ 
/* var2_lower_bound var2_upper bound ...                       */ 
/***************************************************************/ 
 
void initialize(void) 
{ 
FILE *infile; 
int i, j; 
double lbound, ubound; 
 
if ((infile = fopen("gadata.txt","r"))==NULL) 
      { 
      fprintf(galog,"\nCannot open input file!\n"); 
      exit(1); 
      } 
 
/* initialize variables within the bounds */ 
 
for (i = 0; i < NVARS; i++) 
      { 
      fscanf(infile, "%lf",&lbound); 
      fscanf(infile, "%lf",&ubound); 
 
      for (j = 0; j < POPSIZE; j++) 
           { 
           population[j].fitness = 0; 
           population[j].rfitness = 0; 
           population[j].cfitness = 0; 
           population[j].lower = lbound; 
           population[j].upper= ubound; 
           population[j].gene = randval(population[j].lower, 
                                   population[j].upper); 
           } 
      } 
 
fclose(infile); 
} 
 
/***********************************************************/ 
/* Random value generator: Generates a value within bounds */ 
/***********************************************************/ 
 
double randval(double low, double high) 
{ 
double val; 
val = ((double)(rand()%1000)/1000.0)*(high - low) + low; 
return(val); 
} 
 
/*************************************************************/ 
/* Evaluation function: This takes a user defined function.  */ 
/* Each time this is changed, the code has to be recompiled. */ 
/* The current function is:  x[1]^2-x[1]*x[2]+x[3]           */ 
/*************************************************************/ 
 
void evaluate(void) 
{ 
int mem; 
int i; 
double x[NVARS+1]; 
 
for (mem = 0; mem < POPSIZE; mem++) 
      { 
      for (i = 0; i < NVARS; i++) 
            x[i+1] = population[mem].gene; 
 
      population[mem].fitness = (x[1]*x[1]) - (x[1]*x[2]) + x[3]; 
      } 
} 
 
/***************************************************************/ 
/* Keep_the_best function: This function keeps track of the    */ 
/* best member of the population. Note that the last entry in  */ 
/* the array Population holds a copy of the best individual    */ 
/***************************************************************/ 
 
void keep_the_best() 
{ 
int mem; 
int i; 
cur_best = 0; /* stores the index of the best individual */ 
 
for (mem = 0; mem < POPSIZE; mem++) 
      { 
      if (population[mem].fitness > population[POPSIZE].fitness) 
            { 
            cur_best = mem; 
            population[POPSIZE].fitness = population[mem].fitness; 
            } 
      } 
/* once the best member in the population is found, copy the genes */ 
for (i = 0; i < NVARS; i++) 
      population[POPSIZE].gene = population[cur_best].gene; 
} 
 
/****************************************************************/ 
/* Elitist function: The best member of the previous generation */ 
/* is stored as the last in the array. If the best member of    */ 
/* the current generation is worse then the best member of the  */ 
/* previous generation, the latter one would replace the worst  */ 
/* member of the current population                             */ 
/****************************************************************/ 
 
void elitist() 
{ 
int i; 
double best, worst;             /* best and worst fitness values */ 
int best_mem, worst_mem; /* indexes of the best and worst member */ 
 
best = population[0].fitness; 
worst = population[0].fitness; 
for (i = 0; i < POPSIZE - 1; ++i) 
      { 
      if(population.fitness > population[i+1].fitness) 
            { 
            if (population.fitness >= best) 
                  { 
                  best = population.fitness; 
                  best_mem = i; 
                  } 
            if (population[i+1].fitness <= worst) 
                  { 
                  worst = population[i+1].fitness; 
                  worst_mem = i + 1; 
                  } 
            } 
      else 
            { 
            if (population.fitness <= worst) 
                  { 
                  worst = population.fitness; 
                  worst_mem = i; 
                  } 
            if (population[i+1].fitness >= best) 
                  { 
                  best = population[i+1].fitness; 
                  best_mem = i + 1; 
                  } 
            } 
      } 
/* if best individual from the new population is better than */ 
/* the best individual from the previous population, then    */ 
/* copy the best from the new population; else replace the   */ 
/* worst individual from the current population with the     */ 
/* best one from the previous generation                     */ 
 
if (best >= population[POPSIZE].fitness) 
    { 
    for (i = 0; i < NVARS; i++) 
       population[POPSIZE].gene = population[best_mem].gene; 
    population[POPSIZE].fitness = population[best_mem].fitness; 
    } 
else 
    { 
    for (i = 0; i < NVARS; i++) 
       population[worst_mem].gene = population[POPSIZE].gene; 
    population[worst_mem].fitness = population[POPSIZE].fitness; 
    } 
} 
/**************************************************************/ 
/* Selection function: Standard proportional selection for    */ 
/* maximization problems incorporating elitist model - makes  */ 
/* sure that the best member survives                         */ 
/**************************************************************/ 
 
void select(void) 
{ 
int mem, i, j, k; 
double sum = 0; 
double p; 
 
/* find total fitness of the population */ 
for (mem = 0; mem < POPSIZE; mem++) 
      { 
      sum += population[mem].fitness; 
      } 
 
/* calculate relative fitness */ 
for (mem = 0; mem < POPSIZE; mem++) 
      { 
      population[mem].rfitness =  population[mem].fitness/sum; 
      } 
population[0].cfitness = population[0].rfitness; 
 
/* calculate cumulative fitness */ 
for (mem = 1; mem < POPSIZE; mem++) 
      { 
      population[mem].cfitness =  population[mem-1].cfitness + 
                          population[mem].rfitness; 
      } 
 
/* finally select survivors using cumulative fitness. */ 
 
for (i = 0; i < POPSIZE; i++) 
      { 
      p = rand()%1000/1000.0; 
      if (p < population[0].cfitness) 
            newpopulation = population[0]; 
      else 
            { 
            for (j = 0; j < POPSIZE;j++) 
                  if (p >= population[j].cfitness && 
                              p<population[j+1].cfitness) 
                        newpopulation = population[j+1]; 
            } 
      } 
/* once a new population is created, copy it back */ 
 
for (i = 0; i < POPSIZE; i++) 
      population = newpopulation; 
} 
 
/***************************************************************/ 
/* Crossover selection: selects two parents that take part in  */ 
/* the crossover. Implements a single point crossover          */ 
/***************************************************************/ 
 
void crossover(void) 
{ 
int i, mem, one; 
int first  =  0; /* count of the number of members chosen */ 
double x; 
 
for (mem = 0; mem < POPSIZE; ++mem) 
      { 
      x = rand()%1000/1000.0; 
      if (x < PXOVER) 
            { 
            ++first; 
            if (first % 2 == 0) 
                  Xover(one, mem); 
            else 
                  one = mem; 
            } 
      } 
} 
/**************************************************************/ 
/* Crossover: performs crossover of the two selected parents. */ 
/**************************************************************/ 
 
void Xover(int one, int two) 
{ 
int i; 
int point; /* crossover point */ 
 
/* select crossover point */ 
if(NVARS > 1) 
   { 
   if(NVARS == 2) 
         point = 1; 
   else 
         point = (rand() % (NVARS - 1)) + 1; 
 
   for (i = 0; i < point; i++) 
        swap(&population[one].gene, &population[two].gene); 
 
   } 
} 
 
/*************************************************************/ 
/* Swap: A swap procedure that helps in swapping 2 variables */ 
/*************************************************************/ 
 
void swap(double *x, double *y) 
{ 
double temp; 
 
temp = *x; 
*x = *y; 
*y = temp; 
 
} 
 
/**************************************************************/ 
/* Mutation: Random uniform mutation. A variable selected for */ 
/* mutation is replaced by a random value between lower and   */ 
/* upper bounds of this variable                              */ 
/**************************************************************/ 
 
void mutate(void) 
{ 
int i, j; 
double lbound, hbound; 
double x; 
 
for (i = 0; i < POPSIZE; i++) 
      for (j = 0; j < NVARS; j++) 
            { 
            x = rand()%1000/1000.0; 
            if (x < PMUTATION) 
                  { 
                  /* find the bounds on the variable to be mutated */ 
                  lbound = population.lower[j]; 
                  hbound = population.upper[j]; 
                  population.gene[j] = randval(lbound, hbound); 
                  } 
            } 
} 
 
/***************************************************************/ 
/* Report function: Reports progress of the simulation. Data   */ 
/* dumped into the  output file are separated by commas        */ 
/***************************************************************/ 
 
void report(void) 
{ 
int i; 
double best_val;            /* best population fitness */ 
double avg;                 /* avg population fitness */ 
double stddev;              /* std. deviation of population fitness */ 
double sum_square;          /* sum of square for std. calc */ 
double square_sum;          /* square of sum for std. calc */ 
double sum;                 /* total population fitness */ 
 
sum = 0.0; 
sum_square = 0.0; 
 
for (i = 0; i < POPSIZE; i++) 
      { 
      sum += population.fitness; 
      sum_square += population.fitness * population.fitness; 
      } 
 
avg = sum/(double)POPSIZE; 
square_sum = avg * avg * POPSIZE; 
stddev = sqrt((sum_square - square_sum)/(POPSIZE - 1)); 
best_val = population[POPSIZE].fitness; 
 
fprintf(galog, "\n%5d,      %6.3f, %6.3f, %6.3f \n\n", generation, 
                                      best_val, avg, stddev); 
} 
 
/**************************************************************/ 
/* Main function: Each generation involves selecting the best */ 
/* members, performing crossover & mutation and then          */ 
/* evaluating the resulting population, until the terminating */ 
/* condition is satisfied                                     */ 
/**************************************************************/ 
 
void main(void) 
{ 
int i; 
 
if ((galog = fopen("galog.txt","w"))==NULL) 
      { 
      exit(1); 
      } 
generation = 0; 
 
fprintf(galog, "\n generation  best  average  standard \n"); 
fprintf(galog, " number      value fitness  deviation \n"); 
 
initialize(); 
evaluate(); 
keep_the_best(); 
while(generation<MAXGENS) 
      { 
      generation++; 
      select(); 
      crossover(); 
      mutate(); 
      report(); 
      evaluate(); 
      elitist(); 
      } 
fprintf(galog,"\n\n Simulation completed\n"); 
fprintf(galog,"\n Best member: \n"); 
 
for (i = 0; i < NVARS; i++) 
   { 
   fprintf (galog,"\n var(%d) = %3.3f",i,population[POPSIZE].gene); 
   } 
fprintf(galog,"\n\n Best fitness = %3.3f",population[POPSIZE].fitness); 
fclose(galog); 
printf("Success\n"); 
} 
/***************************************************************/

赞回复

vfdff(作者)

2010-08-08 00:13

2

Floyd算法2.cpp 
 
/*  遗传算法示例源程序                            */ 
/* <a href="http://bingyusky.blogchina.com/2373885.html" target="_blank">http://bingyusky.blogchina.com/2373885.html</a>    */ 
 
 
/*转自：<a href="http://www.lasg.ac.cn/cgi-bin/forum/topic.cgi?forum=4&topic=1535" target="_blank">http://www.lasg.ac.cn/cgi-bin/forum/topic.cgi?forum=4&topic=1535</a>*/ 
 
/***************************************************************/ 
/* This is a simple genetic algorithm implementation where the */ 
/* evaluation function takes positive values only and the      */ 
/* fitness of an individual is the same as the value of the    */ 
/* objective function                                          */ 
/***************************************************************/ 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <math.h> 
 
/* Change any of these parameters to match your needs */ 
 
#define POPSIZE 50               /* population size */ 
#define MAXGENS 1000             /* max. number of generations */ 
#define NVARS 3                  /* no. of problem variables */ 
#define PXOVER 0.8               /* probability of crossover */ 
#define PMUTATION 0.15           /* probability of mutation */ 
#define TRUE 1 
#define FALSE 0 
 
int generation;                  /* current generation no. */ 
int cur_best;                    /* best individual */ 
FILE *galog;                     /* an output file */ 
 
struct genotype /* genotype (GT), a member of the population */ 
{ 
double gene[NVARS];        /* a string of variables */ 
double fitness;            /* GT's fitness */ 
double upper[NVARS];       /* GT's variables upper bound */ 
double lower[NVARS];       /* GT's variables lower bound */ 
double rfitness;           /* relative fitness */ 
double cfitness;           /* cumulative fitness */ 
}; 
 
struct genotype population[POPSIZE+1];    /* population */ 
struct genotype newpopulation[POPSIZE+1]; /* new population; */ 
                                        /* replaces the */ 
                                        /* old generation */ 
 
/* Declaration of procedures used by this genetic algorithm */ 
 
void initialize(void); 
double randval(double, double); 
void evaluate(void); 
void keep_the_best(void); 
void elitist(void); 
void select(void); 
void crossover(void); 
void Xover(int,int); 
void swap(double *,double *); 
void mutate(void); 
void report(void); 
 
/***************************************************************/ 
/* Initialization function: Initializes the values of genes    */ 
/* within the variables bounds. It also initializes (to zero)  */ 
/* all fitness values for each member of the population. It    */ 
/* reads upper and lower bounds of each variable from the      */ 
/* input file `gadata.txt'. It randomly generates values       */ 
/* between these bounds for each gene of each genotype in the  */ 
/* population. The format of the input file `gadata.txt' is    */ 
/* var1_lower_bound var1_upper bound                           */ 
/* var2_lower_bound var2_upper bound ...                       */ 
/***************************************************************/ 
 
void initialize(void) 
{ 
FILE *infile; 
int i, j; 
double lbound, ubound; 
 
if ((infile = fopen("gadata.txt","r"))==NULL) 
    { 
    fprintf(galog,"nCannot open input file!n"); 
    exit(1); 
    } 
 
/* initialize variables within the bounds */ 
 
for (i = 0; i [color=#555555] = lbound; 
         population[j].upper= ubound; 
         population[j].gene = randval(population[j].lower, 
                                 population[j].upper); 
         } 
    } 
 
fclose(infile); 
} 
 
/***********************************************************/ 
/* Random value generator: Generates a value within bounds */ 
/***********************************************************/ 
 
double randval(double low, double high) 
{ 
double val; 
val = ((double)(rand()%1000)/1000.0)*(high - low) + low; 
return(val); 
} 
 
/*************************************************************/ 
/* Evaluation function: This takes a user defined function.  */ 
/* Each time this is changed, the code has to be recompiled. */ 
/* The current function is:  x[1]^2-x[1]*x[2]+x[3]           */ 
/*************************************************************/ 
 
void evaluate(void) 
{ 
int mem; 
int i; 
double x[NVARS+1]; 
 
for (mem = 0; mem [color=#555555]; 
 
    population[mem].fitness = (x[1]*x[1]) - (x[1]*x[2]) + x[3]; 
    } 
} 
 
/***************************************************************/ 
/* Keep_the_best function: This function keeps track of the    */ 
/* best member of the population. Note that the last entry in  */ 
/* the array Population holds a copy of the best individual    */ 
/***************************************************************/ 
 
void keep_the_best() 
{ 
int mem; 
int i; 
cur_best = 0; /* stores the index of the best individual */ 
 
for (mem = 0; mem  population[POPSIZE].fitness) 
          { 
          cur_best = mem; 
          population[POPSIZE].fitness = population[mem].fitness; 
          } 
    } 
/* once the best member in the population is found, copy the genes */ 
for (i = 0; i [color=#555555] = population[cur_best].gene; 
} 
 
/****************************************************************/ 
/* Elitist function: The best member of the previous generation */ 
/* is stored as the last in the array. If the best member of    */ 
/* the current generation is worse then the best member of the  */ 
/* previous generation, the latter one would replace the worst  */ 
/* member of the current population                             */ 
/****************************************************************/ 
 
void elitist() 
{ 
int i; 
double best, worst;             /* best and worst fitness values */ 
int best_mem, worst_mem; /* indexes of the best and worst member */ 
 
best = population[0].fitness; 
worst = population[0].fitness; 
for (i = 0; i [color=#555555].fitness > population[i+1].fitness) 
          { 
          if (population.fitness >= best) 
                { 
                best = population.fitness; 
                best_mem = i; 
                } 
          if (population[i+1].fitness [color=#555555].fitness [color=#555555].fitness; 
                worst_mem = i; 
                } 
          if (population[i+1].fitness >= best) 
                { 
                best = population[i+1].fitness; 
                best_mem = i + 1; 
                } 
          } 
    } 
/* if best individual from the new population is better than */ 
/* the best individual from the previous population, then    */ 
/* copy the best from the new population; else replace the   */ 
/* worst individual from the current population with the     */ 
/* best one from the previous generation                     */ 
 
if (best >= population[POPSIZE].fitness) 
  { 
  for (i = 0; i [color=#555555] = population[best_mem].gene; 
  population[POPSIZE].fitness = population[best_mem].fitness; 
  } 
else 
  { 
  for (i = 0; i [color=#555555] = population[POPSIZE].gene; 
  population[worst_mem].fitness = population[POPSIZE].fitness; 
  } 
} 
/**************************************************************/ 
/* Selection function: Standard proportional selection for    */ 
/* maximization problems incorporating elitist model - makes  */ 
/* sure that the best member survives                         */ 
/**************************************************************/ 
 
void select(void) 
{ 
int mem, i, j, k; 
double sum = 0; 
double p; 
 
/* find total fitness of the population */ 
for (mem = 0; mem [color=#555555] = population[0]; 
    else 
          { 
          for (j = 0; j = population[j].cfitness && 
                            p[color=#555555] = population[j+1]; 
          } 
    } 
/* once a new population is created, copy it back */ 
 
for (i = 0; i [color=#555555] = newpopulation; 
} 
 
/***************************************************************/ 
/* Crossover selection: selects two parents that take part in  */ 
/* the crossover. Implements a single point crossover          */ 
/***************************************************************/ 
 
void crossover(void) 
{ 
int i, mem, one; 
int first  =  0; /* count of the number of members chosen */ 
double x; 
 
for (mem = 0; mem  1) 
{ 
if(NVARS == 2) 
       point = 1; 
else 
       point = (rand() % (NVARS - 1)) + 1; 
 
for (i = 0; i [color=#555555], &population[two].gene); 
 
} 
} 
 
/*************************************************************/ 
/* Swap: A swap procedure that helps in swapping 2 variables */ 
/*************************************************************/ 
 
void swap(double *x, double *y) 
{ 
double temp; 
 
temp = *x; 
*x = *y; 
*y = temp; 
 
} 
 
/**************************************************************/ 
/* Mutation: Random uniform mutation. A variable selected for */ 
/* mutation is replaced by a random value between lower and   */ 
/* upper bounds of this variable                              */ 
/**************************************************************/ 
 
void mutate(void) 
{ 
int i, j; 
double lbound, hbound; 
double x; 
 
for (i = 0; i [color=#555555].lower[j]; 
                hbound = population.upper[j]; 
                population.gene[j] = randval(lbound, hbound); 
                } 
          } 
} 
 
/***************************************************************/ 
/* Report function: Reports progress of the simulation. Data   */ 
/* dumped into the  output file are separated by commas        */ 
/***************************************************************/ 
 
void report(void) 
{ 
int i; 
double best_val;            /* best population fitness */ 
double avg;                 /* avg population fitness */ 
double stddev;              /* std. deviation of population fitness */ 
double sum_square;          /* sum of square for std. calc */ 
double square_sum;          /* square of sum for std. calc */ 
double sum;                 /* total population fitness */ 
 
sum = 0.0; 
sum_square = 0.0; 
 
for (i = 0; i [color=#555555].fitness; 
    sum_square += population.fitness * population.fitness; 
    } 
 
avg = sum/(double)POPSIZE; 
square_sum = avg * avg * POPSIZE; 
stddev = sqrt((sum_square - square_sum)/(POPSIZE - 1)); 
best_val = population[POPSIZE].fitness; 
 
fprintf(galog, "n%5d,      %6.3f, %6.3f, %6.3f nn", generation, 
                                    best_val, avg, stddev); 
} 
 
/**************************************************************/ 
/* Main function: Each generation involves selecting the best */ 
/* members, performing crossover & mutation and then          */ 
/* evaluating the resulting population, until the terminating */ 
/* condition is satisfied                                     */ 
/**************************************************************/ 
 
void main(void) 
{ 
int i; 
 
if ((galog = fopen("galog.txt","w"))==NULL) 
    { 
    exit(1); 
    } 
generation = 0; 
 
fprintf(galog, "n generation  best  average  standard n"); 
fprintf(galog, " number      value fitness  deviation n"); 
 
initialize(); 
evaluate(); 
keep_the_best(); 
while(generation[color=#555555]); 
} 
fprintf(galog,"nn Best fitness = %3.3f",population[POPSIZE].fitness); 
fclose(galog); 
printf("Successn"); 
} 
/***************************************************************/

赞回复

vfdff(作者)

2010-08-08 00:14

3

3元函数求解.cpp 
 
/* 
[问题描述] 
 
    有形如：ax3+bx2+cx+d=0这样的一个一元三次方程。给出该方程中各项的系数(a， 
 
b，c，d  均为实数)，并约定该方程存在三个不同实根(根的范围在-100至100之间)， 
 
且根与根之差的绝对值≥1。 
 
    要求由小到大依次在同一行输出这三个实根(根与根之间留有空格)，并精确到小数点 
 
后2位。 
 
 
 
提示；记方程f(x)=0，若存在2个数x1和x2，且x1 < x2，f(x1)*f(x2) < 0， 
 
    则在(x1，x2)之间一定有一个根。 
 
[样例] 
 
    输入：  1  -5  -4  20 
 
    输出：-2．00  2．00  5．00 
 
问题分析 
 
根据题意，三次方程 ax^3+bx^2+cx+d=0在区间[-100,100]有3个不等实根，不妨设这3个实根分别为x1,x2,x3，且x1<x2<x3，则方程可表示为a(x-x1)(x-x2)(x-x3)=0;于是，求解这3个实根，可转化为求函数f(x)= a(x-x1)(x-x2)(x-x3)图像与x轴交点的横坐标。如图： 
 
 
 
 
二分法： 
 
 
 
1．  确定根的区间 
 
考虑在什么样的区间内会有根，由于题目给出了所有的根都在－100到100之间，且根与根之间的差不小于1的限制条件，可知，在[-100,100]，[-99,-98],…[99,100],[100,100]这201个区间内，每个区间内至多只能存在一个根，这样除去区间[100,100]外，其他区间[a,a+1],要么f(a)=0,要么f(a)×f(a+1)<0时这个方程在此区间内才有解。 
 
2．  求方程的根 
 
确定了方程f(x)=0在区间（a,b）内如果有且只有一个根，那么我们可以有逐步缩小根可能存在的范围的方法确定出某精度下根的数值。本题规定根的精度是0.01，下面采用二分法求区间（a,b）内方程的根，过程如下： 
 
（1）       取当前可能存在解的区间（a,b）; 
 
（2）       若a+0.001>b或 f((a+b)/2)=0,则可确定根为（a+b）/2并退出过程； 
 
（3）       若f(a)×f((a+b)/2)<0,则根在区间（a, (a+b)/2）中，故对区间（a, (a+b)/2）重复该过程； 
 
（4）       若f(a)× f((a+b)/2)>0,则必然有 f((a+b)/2)×f(b)<0，也就是说根在（(a+b)/2,b）中，应该对此区间重复该过程。 
 
二分法求根的算法如下： 
 
*/ 
#include<iostream> 
 
#include<cmath> 
 
using namespace std; 
 
double x[3]; 
 
double a,b,c,d,u,v; 
 
int i,t; 
 
double f(double x) 
 
{ 
 
     double temp; 
 
     temp=((a*x+b)*x+c)*x+d; 
 
     return temp; 
 
} 
 
int main() 
 
{ 
 
         while(cin>>a>>b>>c>>d) 
 
      { 
 
          t=-1; 
 
          for(i=-100;i<=100;i++) 
 
           { 
 
               u=double(i); 
 
               v=u+0.99999; 
 
               if(fabs(f(u))<0.00001||f(u)*f(v)<=0) 
 
                { 
 
                    t++; 
 
                    if(fabs(f(u))<0.00001) 
 
                       x[t]=u; 
 
                    else 
 
                       { 
 
                        while((u+0.001<v)&&fabs(f((u+v)/2))>=0.00001) 
 
 
 
                           { 
 
                               if(f(u)*f((u+v)/2)<0) 
 
                                 v=(u+v)/2; 
 
                               else 
 
                                 u=(u+v)/2; 
 
                           } 
 
                        x[t]=(u+v)/2; 
 
                       } 
 
                } 
 
           } 
 
      cout.setf(ios::fixed); 
 
      cout.precision(2); 
 
      cout<<x[0]<<" "<<x[1]<<" "<<x[2]<<endl; 
 
      } 
 
 
 
     return 0; 
 
}

赞回复

vfdff(作者)

2010-08-08 00:17

4

数值积分 
 
// 2006.6.13  C&C++ 实效编程百例人民邮电出版社 page 167 
/* 
  积分函数 ∫4/(1+x*x) dx     0<=x<=1 
   
*/ 
 
 
#include    <iostream.h> 
#include    <iomanip.h> 
#include    <math.h> 
#define  PI  3.141592653589793238462643 
class CIntegral 
{ 
    public: 
        double a,b;                         // 成员变量，分别表示积分的上下界 
        double epsilon,MaxD;                // 成员变量，分别表示积分的误差限和倒数限 
        CIntegral(double ,double );         // 构造函数, 没有返回类型 
        double f(double);                   // 成员函数，描述积分函数的运算函数 
        double Simpson(void);               // 成员函数，表示Simpson公式的运算过程，返回运算结果 
}; 
 
CIntegral::CIntegral(double xa,double xb)   // 构造函数， 
{ 
    epsilon=0.5E-8;             // 事先规定的误差限 
    MaxD=24.0;                  // 表示这个区间导数的最大值 
    a=xa; 
    b=xb; 
} 
 
double CIntegral::f(double x)   // 成员函数，描述积分函数的运算函数 
{ 
    return 4.0/(1.0+x*x); 
} 
 
double CIntegral::Simpson(void) // 成员函数，表示Simpson公式的运算过程，返回运算结果 
{ 
    double h,s,x;               // y(0)初值为 1 ，h 第一段步长为 0.01 
    int i,n; 
    // 利用误差公式计算 h 
    h=2*exp(log(epsilon*180/MaxD/(b-a))*0.25); 
    n=(int)((b-a)/h+0.5);       // n 表示分段数目 
    h=(b-a)/double(n);          // h 表示积分步长 
    // 计算 s 
    s=0.0; 
    for(x=a,i=0;i<n;i++,x+=h) 
    {   // 复化辛普生求积分公式 
        s+=h/6*(f(x)+4*f(x+h/2)+f(x+h)); 
    } 
    // 返回 s ,为最终的积分数值 
    return s; 
} 
 
void main() 
{ 
    CIntegral test(0.0,1.0);   // 生成 CIntegral 类的对象 test,并给出上下限 
    double res=test.Simpson(); // 计算积分 
    setprecision(16); 
    cout<<res<<endl;           // 输出结果 
    cout<<PI-res<<endl;        // 输出误差 
}

赞回复

vfdff(作者)

2010-08-08 00:20

5

循环报数 
 
 
#include <stdio.h> 
#define  MAX  54 
#define  M    7 
int count =5; 
main() 
{ 
   int n=MAX, a[MAX],b[MAX],i,qn=0; 
   for(i=0;i<MAX;i++)   a=i+1; 
   i=0; 
   while(qn<MAX)  { 
       for(;i<n;i++)  { 
           count++; 
           if(count == M) 
           {qn++; b[MAX-n]=a;n--;a=a[n];count=0;break; } 
       } 
       if(n==i) i=0 ; 
   } 
   for(i=0;i<MAX;i++)   printf("%d\t",b); 
}

赞回复

vfdff(作者)

2010-08-08 00:20

6

// 2006.6.13  C&C++ 实效编程百例人民邮电出版社 page 168 
/* 
 
  微分函数 y'=-20y+20sin(t)+cos(t) 
           y(0)=1           0<=t<=1 
  原函数   y(t)=exp(-20t)+sin(t) 
  龙格-库塔算法: 
  y(n+1)=y(n)+h/6(K1+2*K2+2*k3+K4) 
  K1=f(x(n),y(n)) 
  k2=f(x(n)+h/2,y(n)+h/2*k1) 
  k3=f(x(n)+h/2,y(n)+h/2*k2) 
  k4=f(x(n)+h,y(n)+h*k3) 
 
*/ 
 
#include    <stdio.h> 
#include    <math.h> 
 
class CDiff 
{ 
    public: 
        double h,y;                 // 成员变量，分别表示运算步长和计算结果 
        double k1,k2,k3,k4;         // 成员变量，表示公式运行的中间结果 
        double f(double,double);    // 成员函数，描述微分方程的表达式 
        double Runge(void);         // 成员函数，进行龙格-库塔公式的计算，并输出最终结果 
}; 
 
double CDiff::f(double x,double y)  // 成员函数，描述微分方程的表达式 
{ 
    return -20*y+20*sin(x)+cos(x); 
} 
 
double CDiff::Runge(void)          // 成员函数，进行龙格-库塔公式的计算，并输出最终结果 
{ 
    double y=1,h=0.01;             // y(0)初值为 1 ，h 第一段步长为 0.01 
    double k1,k2,k3,k4; 
    double t; 
    for(t=0;t<0.2;t+=h) 
    { 
        k1=f(t,y); 
        k2=f(t+h/2,y+h*k1/2); 
        k3=f(t+h/2,y+h*k2/2); 
        k4=f(t+h,y+h*k3); 
        y+=h/6*(k1+2*k2+2*k3+k4); 
    } 
    h=0.075;                       // h 第二段步长为 0.075 
    for(t=0.2;t<1;t+=h) 
    { 
        k1=f(t,y); 
        k2=f(t+h/2,y+h*k1/2); 
        k3=f(t+h/2,y+h*k2/2); 
        k4=f(t+h,y+h*k3); 
        y+=h/6*(k1+2*k2+2*k3+k4); 
    } 
    h=1-t; 
    k1=f(t,y); 
    k2=f(t+h/2,y+h*k1/2); 
    k3=f(t+h/2,y+h*k2/2); 
    k4=f(t+h,y+h*k3); 
    y+=h/6*(k1+2*k2+2*k3+k4); 
    // 返回y ,为最终积分数值 
    return y ; 
} 
 
void main() 
{ 
    CDiff test;                                     // 生成 CDiff 类的对象 test 
    double res=test.Runge();                        // 计算积分 
    printf("y(1)=%.16f\n",res);                     // 输出结果 
    printf("e=%.16f\n",exp(-20.0)+sin(1.0)-res);    // 输出误差 
}

赞回复

vfdff(作者)

2010-08-08 00:20

7

#include<iostream.h> 
 
float linesqr(float x1,float y1,float x2,float y2) 
{return (x2-x1)*(y1+y2)/2.0;} 
 
void main() 
{ 
float fx,fy,x1,y1,x2,y2,s=0.0; 
int n,i; 
cout<<"多边形的顶点数"; 
do{cin>>n;} 
while(n<3); 
cout<<"第1个点坐标"<<endl; 
cin>>x1>>y1;fx=x1;fy=y1; 
cout<<"第2个点坐标"<<endl; 
cin>>x2>>y2; 
s=linesqr(x1,y1,x2,y2); 
for(i=3;i<=n;++i) 
{ 
  x1=x2;y1=y2; 
  cout<<"第"<<i<<"个点坐标"<<endl; 
  cin>>x2>>y2; 
  s+=linesqr(x1,y1,x2,y2); 
} 
s+=linesqr(x2,y2,fx,fy);//首尾相连 
cout<<"多边形的面积为"<<s<<endl; 
} 
 
/*******************************************************************************| 
今天在论坛看到这样一个问题，程序输入一系列的点，按输入顺序首尾相连构成一个多边形，如何求这个多边形的面积？ 
 
　　其实方法很简单，定积分。我还是简单解释一下，如果是没有读过高等数学的朋友，也让你大致明白。 
　　定积分的本质是求和，计算f(x)在积分区间[a,b]上的一个和Ｓ，首先把积分区间分成n份，这样的分法记为λ， 
记Δ(λ)=max{Δx|[xi-1,xi]}，也就是所有这些分成的小段中长度最大的一段的长，如果当Δ→０的时候， 
和式Ｓ＝∑f(θ)Δx (θ∈[xi-1,xi])的极限如果存在的话，就称其为f(x)在[a,b]上的定积分，记为 
b 
∫f(x)dx 
a 
　　其意义从几何上解释，就是f(x)的曲线与x轴、直线x=a,x=b围成的图形的面积。 
　　现在要求的多边形是由线段组成的，只要把所有的线段都求定积分，最后把和加起来，就是多边形的面积。 
这个推论的证明从略。值得注意的是，用定积分求的面积有正负之分，即： 
b         a 
∫f(x)dx=-∫f(x)dx 
a         b 
从a积到b，与从b积到a只相差一个负号。 
 
　　线段定积分的计算公式的推导 
 
给出两个点，如何求这两点连成的线段的定积分值呢？ 
直线的方程可以用y=kx+b表示，所以围成的面积 
S= 
x2 
∫(kx+b)dx 
x1 
=k/2(x2^2-x1^2)+b(x2-x1) 
 
而斜率k=(y2-y1)/(x2-x1) 
截距b=y1-kx1=y1-x1(y2-y1)/(x2-x1)，代入前式得 
S=(y2-y1)(x2+x1)/2+y1(x2-x1)-x1(y2-y1) 
=(x2-x1)(y1+y2)/2 
这让我想到一个初等公式，梯形面积公式，y1,y2看成上下底，(x2-x1)看成是高，上底加下底乘高除二， 
对直线定积分得到的正是这个梯形的面积。这样走了一个大弯又回到初中了。 
\*******************************************************************************/

赞回复

vfdff(作者)

2010-08-08 00:21

8

24点算法 
 
#include<iostream.h> 
#include<conio.h> 
//#include<conio.c> 
#include<math.h> 
#include<string.h> 
#include<stdio.h> 
#include<stdlib.h> 
 
char sig[4]= 
{ 
    '+','-','*','/' 
} 
; 
 
void fun(float n[],char ch[][50],int m) 
{ 
    int x[2],y,i,j ; 
    float num[4]; 
    char cc[4][50]; 
    if(m==1) 
    { 
        if(fabs(n[0]-24.0)<0.0001) 
        { 
            cout<<"\n%s=24"<<ch[0]; getch(); exit(0); 
        } 
    } 
    else 
    { 
        for(x[0]=0;x[0]<m;x[0]++) 
        { 
            for(x[1]=0;x[1]<m;x[1]++) 
            { 
                if(x[1]==x[0]) continue ; 
                for(y=0;y<4;y++)    /* + - * / 四种运算 */ 
                { 
                    switch(y) 
                    { 
                        case 0 : num[0]=n[x[0]]+n[x[1]]; break ; 
                        case 1 : num[0]=n[x[0]]-n[x[1]]; break ; 
                        case 2 : num[0]=n[x[0]]*n[x[1]]; break ; 
                        case 3 : if(n[x[1]]==0) break ;  /* 分母不能是 0 */ 
                                     num[0]=n[x[0]]/n[x[1]]; break ; 
                        default : break ; 
                    } 
                    if(y!=3||n[x[1]]!=0) 
                    sprintf(cc[0],"(%s%c%s)",ch[x[0]],sig[y],ch[x[1]]); 
                    for(i=0,j=1;i<m;i++) 
                    if(i!=x[0]&&i!=x[1]) 
                    { 
                        num[j]=n; 
                        strcpy(cc[j],ch); 
                        j++; 
                    } 
                    fun(num,cc,m-1); 
                } 
            } 
        } 
    } 
} 
 
/***********************/ 
main() 
{ 
    float num[4]; 
    int i ; 
    char cx[4][50]; 
 
    //clrscr(); 
    cout<<"请输入４个数" ; 
    for(i=0;i<4;i++) 
    //cin>>"%f">>num; 
    scanf("%f",num); 
 
    for(i=0;i<4;i++) 
    { 
        sprintf(cx,"%d",(int)num); 
    } 
 
    fun(num,cx,4); 
    cout<<"无解" ; 
    getch(); 
}

赞回复

vfdff(作者)

2010-08-08 00:24

9

// Tc 下菜单设计 
 
#include <stdlib.h> 
#include <graphics.h> 
#include <dos.h> 
#include <conio.h> 
#include <alloc.h> 
int m=1,k=1,ak1[5],ak2[5]={1,1,1,1,1}; 
invel(int); 
sav(char*abn[]) 
{ 
    void*buf ; 
    unsigned s ; 
    union scan 
    { 
        int c ; 
        char ch[2]; 
    } 
    sc ; 
    int j=ak1[k],i,I ; 
    int x1=10+(k-1)*120 ; 
    int x2=x1+100 ; 
    int y1=28 ; 
    int y2=y1+j*10+17 ; 
    s=imagesize(x1,y1,x2,y2); 
    buf=malloc(s); 
    getimage(x1,y1,x2,y2,buf); 
    setviewport(x1,y1,x2,y2,0); 
    clearviewport(); 
    bar(0,0,100,y2-y1); 
    setcolor(0); 
    rectangle(3,3,96,j*10+13); 
    rectangle(6,5,93,j*10+11); 
    for(i=0;i<j;i++) 
    outtextxy(12,i*10+9,abn); 
    I=ak2[k]; 
    inve2(1); 
    i=1 ; 
    for(;i==1;) 
    { 
        sc.c=get key(); 
        if(sc.ch[1]==80) 
        { 
            ak2[k]=ak2[k]+1 ; 
            if(ak2[k]>ak1[k]) 
            ak2[k]=1 ; 
            I=ak2[k]-1 ; 
            if(I==0) 
            I=ak2[k]; 
            inve2(I); 
            I=ak2[k]; 
            inve2(1); 
        } 
        if(sc.ch[1]==72) 
        { 
            ak2[k]-=1 ; 
            if(ak2[k]==0) 
            ak2[k]=ak1[k]; 
            I=ak2[k]+1 ; 
            if(1>ak1[k]) 
            I=1 ; 
            inve2(I); 
            I=ak2[k]; 
            inve2(I); 
        } 
        if(sc.ch[0]==13) 
        { 
            i=0 ; 
            m=0 ; 
        } 
        if(sc.ch[0]==27) 
        i=0 ; 
    } 
    setcolor(1); 
    clearviewport(); 
    setviewport(0,0,639,199,0); 
    putimage(x1,y1,buf,COPY PUT); 
} 
 
invel(int k1) 
{ 
    void *buf1; 
    unsigned s1; 
    int x1,x2; 
    x1=10+(k1-1)*120; 
    x2=x1+45; 
    s1+imagesize(x1,13,x2,21); 
    buf1=malloc(s1); 
    getimage(x1,13,x2,21,buf1); 
    putimage(x1,12,buf1,NOT_PUT); 
} 
 
inve2(int I) 
{ 
    void *buf2; 
    unsigned s2; 
    int y1=(I-1)*10+8; 
    s2=imagesize(6,y1,93,y1+8); 
    buf2=malloc(s2); 
    getimage(6,y1,93,y1+8,buf2); 
    putimage(6,y1,buf2,NOT PUT); 
} 
 
int get key() 
{ 
    union REGS r; 
    r.h.ah=0; 
    return int86(0x16,&r,&r); 
} 
 
mat(char *ar[],int n,char *ar1[],char *ar2[],char *ar3[],char *ar4[]) 
{ 
    char *arn[10][10]; 
    int k1; 
    union scan{ 
        int c; 
        char ch[2]; 
    }sc ; 
    int i,as=DETECT,bs; 
    initgraph(&as,&bs,""); 
    cleardevice(); 
    setactivepage(0); 
    setvisualpage(0); 
    rectangle(5,10,635,195); 
    Iine(5,23,635,23); 
    Iine(5,25,635,25); 
    for(i=0;i<=n;i++) 
        outtextxy(20+i*120,14,ar); 
    inve1(k); 
    i=1; 
    for(;i==1;){ 
        sc.c=get key(); 
        if(sc.ch[0]==13){ 
            switch(k){ 
                case 1: 
                strcpy(arn,ar1); 
                sav(arn); 
                if(m==0) i=0; 
                break; 
                case 2: 
                strcpy(arn,ar2); 
                sav(arn); 
                if(m==0) i=0; 
                break; 
                case 3: 
                strcpy(arn,ar3); 
                sac(arn); 
                if(m==0) i=0; 
                break; 
                case 4: 
                strcpy(arn,ar4); 
                sav(arn); 
                if(m==0) i=0; 
                break; 
            } 
        } 
     if(sc.ch[1]==72){ 
        k=k+1; 
        if(k>(n+1))  k=1; 
        k1=k-1; 
        if(k1==0)   k1=n+1; 
        invel(k1); 
        k1=k; 
        invel(k1); 
     } 
     if(sc.ch[1]==75){ 
        k=k-1; 
        if(k==0) k=n+1; 
        k1=k+1; 
        if(k1>(n+1)) k1=1; 
        invel(k1) ; 
        k1=k; 
        invel(k1); 
     } 
   } 
 
}

赞回复

vfdff(作者)

2010-08-08 00:25

10

简单的计算器 
 
#include<math.h> 
#include<stdlib.h> 
#include<iostream.h> 
class Calculator 
{ 
    double a,b; 
public: 
    Calculator(){a=0;b=0;}; //could be omitted 
    void newa() 
    { 
        double num; 
        cout<<"Input the number:"; 
        cin>>num; 
        a=num; 
    } 
    void newab() 
    { 
        double num1,num2; 
        cout<<"Input the numbers.the first number:"; 
        cin>>num1; 
        cout<<"Input the senond number:"; 
        cin>>num2; 
        a=num1; 
        b=num2; 
    } 
    double Geta(){return a;} 
    double Getb(){return b;} 
    double Add(Calculator &A); 
    double Sub(Calculator *A); 
    double Mul(Calculator &A); 
    double Div(Calculator &A); 
    double Sin(Calculator &A); 
    double Cos(Calculator &A); 
    double Tan(Calculator &A); 
    double Exp(Calculator &A); 
    double Fabs(Calculator &A); 
    double LogE(Calculator &A); 
    double Log10(Calculator &A); 
    double Pow(double x,double y); 
    double Sqrt(double x); 
}; 
double Calculator::Add(Calculator &A) 
{ 
    return A.a+A.b; 
} 
double Calculator::Sub(Calculator *A) 
{ 
    return A->a-A->b; 
} 
double Calculator::Mul(Calculator &A) 
{ 
    return A.a*A.b; 
} 
double Calculator::Div(Calculator &A) 
{ 
    if(A.b==0) 
    {cout<<"Error! The program will be terminated!"<<endl;exit(0);} 
    return A.a/A.b; 
} 
double Calculator::Sin(Calculator &A) 
{ 
    return sin(A.a); 
} 
double Calculator::Cos(Calculator &A) 
{ 
    return cos(A.a); 
} 
double Calculator::Tan(Calculator &A) 
{ 
    return tan(A.a); 
} 
double Calculator::Exp(Calculator &A) 
{ 
    return exp(A.a); 
} 
double Calculator::Fabs(Calculator &A) 
{ 
    return fabs(A.a); 
} 
double Calculator::LogE(Calculator &A) 
{ 
    return log(A.a); 
} 
double Calculator::Log10(Calculator &A) 
{ 
    return log10(A.a); 
} 
double Calculator::Pow(double x,double y) 
{ 
    return pow(x,y); 
} 
double Calculator::Sqrt(double x) 
{ 
    if(x<0) 
    {cout<<"Error! The program will be terminated!"<<endl;exit(0);} 
    return sqrt(x); 
} 
 
void main() 
{ 
    int sel; 
    Calculator cal; 
    cout<<"Welcome to use the calculator!please select."<<endl; 
    cout<<"1:\'+\'    2:\'-\'     3:\'*\'      4:\'/\'     5:\'sin\'   6:\'cos\'  7:\'tan\'"<<endl; 
    cout<<"8:\'exp\'  9:\'fabs\'  10:\'logE\'  11:\'log10\' 12:\'pow\'  13:\'sqrt\'"<<endl; 
    do 
    { 
    cout<<"Please select:(0--exit)"; 
    cin>>sel; 
    switch (sel) 
    { 
    case 0: break; 
    case 1: cal.newab(); 
            cout<<"The result is:"<<cal.Add(cal)<<endl; 
            break; 
    case 2: cal.newab(); 
            cout<<"The result is:"<<cal.Sub(&cal)<<endl; 
            break; 
    case 3: cal.newab(); 
            cout<<"The result is:"<<cal.Mul(cal)<<endl; 
            break; 
    case 4: cal.newab(); 
            cout<<"The result is:"<<cal.Div(cal)<<endl; 
            break; 
    case 5: cal.newa(); 
            cout<<"The result is:"<<cal.Sin(cal)<<endl; 
            break; 
    case 6: cal.newa(); 
            cout<<"The result is:"<<cal.Cos(cal)<<endl; 
            break; 
    case 7: cal.newa(); 
            cout<<"The result is:"<<cal.Tan(cal)<<endl; 
            break; 
    case 8: cal.newa(); 
            cout<<"The result is:"<<cal.Exp(cal)<<endl; 
            break; 
    case 9: cal.newa(); 
            cout<<"The result is:"<<cal.Fabs(cal)<<endl; 
            break; 
    case 10: cal.newa(); 
            cout<<"The result is:"<<cal.LogE(cal)<<endl; 
            break; 
    case 11: cal.newa(); 
            cout<<"The result is:"<<cal.Log10(cal)<<endl; 
            break; 
    case 12: cal.newab(); 
            cout<<"The result is:"<<cal.Pow(cal.Geta(),cal.Getb())<<endl; 
            break; 
    case 13: cal.newa(); 
            cout<<"The result is:"<<cal.Sqrt(cal.Geta())<<endl; 
            break; 
    default: cout<<"Your selection is ERROR! Select again!"<<endl; 
    } 
    }while(sel!=0); 
}

赞回复

vfdff(作者)

2010-08-08 00:26

11

产生随机数 
 
// 利用时间time 做种子，这样每次运行的种子均不一样，从而可以得到真正的随机数 
// 2006.6.13  C&C++ 实效编程百例人民邮电出版社 page 153 
#include    <iostream.h> 
#include    <stdlib.h> 
#include    <time.h> 
 
int main() 
{ 
    srand(time(0));    // 时间 time 做种子 
    for(int i=0;i<9;i++) 
        cout<<rand()<<endl; 
    return 0; 
}

赞回复

vfdff(作者)

2010-08-08 00:34

12

二分法 
 
#define     MAX     3 
#include    <stdio.h> 
static double  data[MAX]; 
 
double Renew(double data[],double x) 
{ 
    int i; 
    double sum = 0.0; 
    for(i=0; i<MAX-1; i++) /* 前MAX-1个数前移 */ 
       data = data[i+1]; 
    data[MAX-1] = x; 
    for(i=0; i<MAX; i++) 
       sum =sum + data; 
    printf("sum=%7.3f",sum); 
    return sum/MAX; 
} 
 
 
 
 
/* 一元全区间不等距插值 */ 
 
double enlgr(double x[],double y[],int n,double t) 
{ 
    int i;   /* 这里假设单调变化,且t在x和x[i-1]之间成立 */ 
    double z; 
    if(t<x[0]+1e-03&&t>x[0]-1e-03)  return y[0]; 
    for(i=1;i<n;i++) 
    { 
        if((x-t)*(x[i-1]-t)<0) break; /* 找到t所在区间 */ 
        if(t<x+1e-03&&t>x-1e-03)  return y; 
    } 
    z=(y-y[i-1])*(t-x[i-1])/(x-x[i-1]); 
    return  z+y[i-1]; 
} 
 
main() 
{ 
    double t,z; 
    static double x[10]={0.10,0.15,0.25,0.40,0.50,0.57,0.70,0.85,0.93,1.00}; 
    static double y[10]={0.904837,0.860708,0.778801,0.670320,0.606531, 
                         0.565525,0.496585,0.427415,0.394554,0.367879}; 
    int i  ; 
    for(i=0;i<10;i++){ 
        t=Renew(data,x); 
        z=enlgr(x,y,10,t); 
        printf("\n"); 
        printf("t=%6.3f,\tz=%e\n",t,z); 
        printf("\n"); 
    } 
}

赞回复

vfdff(作者)

2010-08-08 00:35

13

//遗传算法示例源程序 
//http://www.lasg.ac.cn/cgi-bin/forum/topic.cgi?forum=4&topic=1535 
 
/***************************************************************/ 
/* This is a simple genetic algorithm implementation where the */ 
/* evaluation function takes positive values only and the      */ 
/* fitness of an individual is the same as the value of the    */ 
/* objective function                                          */ 
/***************************************************************/ 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <math.h> 
 
/* Change any of these parameters to match your needs */ 
 
#define POPSIZE 50               /* population size */ 
#define MAXGENS 1000             /* max. number of generations */ 
#define NVARS 3                  /* no. of problem variables */ 
#define PXOVER 0.8               /* probability of crossover */ 
#define PMUTATION 0.15           /* probability of mutation */ 
#define TRUE 1 
#define FALSE 0 
 
int generation;                  /* current generation no. */ 
int cur_best;                    /* best individual */ 
FILE *galog;                     /* an output file */ 
 
struct genotype /* genotype (GT), a member of the population */ 
{ 
double gene[NVARS];        /* a string of variables */ 
double fitness;            /* GT's fitness */ 
double upper[NVARS];       /* GT's variables upper bound */ 
double lower[NVARS];       /* GT's variables lower bound */ 
double rfitness;           /* relative fitness */ 
double cfitness;           /* cumulative fitness */ 
}; 
 
struct genotype population[POPSIZE+1];    /* population */ 
struct genotype newpopulation[POPSIZE+1]; /* new population; */ 
                                        /* replaces the */ 
                                        /* old generation */ 
 
/* Declaration of procedures used by this genetic algorithm */ 
 
void initialize(void); 
double randval(double, double); 
void evaluate(void); 
void keep_the_best(void); 
void elitist(void); 
void select(void); 
void crossover(void); 
void Xover(int,int); 
void swap(double *,double *); 
void mutate(void); 
void report(void); 
 
/***************************************************************/ 
/* Initialization function: Initializes the values of genes    */ 
/* within the variables bounds. It also initializes (to zero)  */ 
/* all fitness values for each member of the population. It    */ 
/* reads upper and lower bounds of each variable from the      */ 
/* input file `gadata.txt'. It randomly generates values       */ 
/* between these bounds for each gene of each genotype in the  */ 
/* population. The format of the input file `gadata.txt' is    */ 
/* var1_lower_bound var1_upper bound                           */ 
/* var2_lower_bound var2_upper bound ...                       */ 
/***************************************************************/ 
 
void initialize(void) 
{ 
FILE *infile; 
int i, j; 
double lbound, ubound; 
 
if ((infile = fopen("gadata.txt","r"))==NULL) 
    { 
    fprintf(galog,"nCannot open input file!n"); 
    exit(1); 
    } 
 
/* initialize variables within the bounds */ 
 
for (i = 0; i [color=0x555555] = lbound; 
         population[j].upper= ubound; 
         population[j].gene = randval(population[j].lower, 
                                 population[j].upper); 
         } 
    } 
 
fclose(infile); 
} 
 
/***********************************************************/ 
/* Random value generator: Generates a value within bounds */ 
/***********************************************************/ 
 
double randval(double low, double high) 
{ 
double val; 
val = ((double)(rand()%1000)/1000.0)*(high - low) + low; 
return(val); 
} 
 
/*************************************************************/ 
/* Evaluation function: This takes a user defined function.  */ 
/* Each time this is changed, the code has to be recompiled. */ 
/* The current function is:  x[1]^2-x[1]*x[2]+x[3]           */ 
/*************************************************************/ 
 
void evaluate(void) 
{ 
int mem; 
int i; 
double x[NVARS+1]; 
 
for (mem = 0; mem [color=#555555]; 
 
    population[mem].fitness = (x[1]*x[1]) - (x[1]*x[2]) + x[3]; 
    } 
} 
 
/***************************************************************/ 
/* Keep_the_best function: This function keeps track of the    */ 
/* best member of the population. Note that the last entry in  */ 
/* the array Population holds a copy of the best individual    */ 
/***************************************************************/ 
 
void keep_the_best() 
{ 
int mem; 
int i; 
cur_best = 0; /* stores the index of the best individual */ 
 
for (mem = 0; mem  population[POPSIZE].fitness) 
          { 
          cur_best = mem; 
          population[POPSIZE].fitness = population[mem].fitness; 
          } 
    } 
/* once the best member in the population is found, copy the genes */ 
for (i = 0; i [color=#555555] = population[cur_best].gene; 
} 
 
/****************************************************************/ 
/* Elitist function: The best member of the previous generation */ 
/* is stored as the last in the array. If the best member of    */ 
/* the current generation is worse then the best member of the  */ 
/* previous generation, the latter one would replace the worst  */ 
/* member of the current population                             */ 
/****************************************************************/ 
 
void elitist() 
{ 
int i; 
double best, worst;             /* best and worst fitness values */ 
int best_mem, worst_mem; /* indexes of the best and worst member */ 
 
best = population[0].fitness; 
worst = population[0].fitness; 
for (i = 0; i [color=#555555].fitness > population[i+1].fitness) 
          { 
          if (population.fitness >= best) 
                { 
                best = population.fitness; 
                best_mem = i; 
                } 
          if (population[i+1].fitness [color=#555555].fitness [color=#555555].fitness; 
                worst_mem = i; 
                } 
          if (population[i+1].fitness >= best) 
                { 
                best = population[i+1].fitness; 
                best_mem = i + 1; 
                } 
          } 
    } 
/* if best individual from the new population is better than */ 
/* the best individual from the previous population, then    */ 
/* copy the best from the new population; else replace the   */ 
/* worst individual from the current population with the     */ 
/* best one from the previous generation                     */ 
 
if (best >= population[POPSIZE].fitness) 
  { 
  for (i = 0; i [color=#555555] = population[best_mem].gene; 
  population[POPSIZE].fitness = population[best_mem].fitness; 
  } 
else 
  { 
  for (i = 0; i [color=#555555] = population[POPSIZE].gene; 
  population[worst_mem].fitness = population[POPSIZE].fitness; 
  } 
} 
/**************************************************************/ 
/* Selection function: Standard proportional selection for    */ 
/* maximization problems incorporating elitist model - makes  */ 
/* sure that the best member survives                         */ 
/**************************************************************/ 
 
void select(void) 
{ 
int mem, i, j, k; 
double sum = 0; 
double p; 
 
/* find total fitness of the population */ 
for (mem = 0; mem [color=#555555] = population[0]; 
    else 
          { 
          for (j = 0; j = population[j].cfitness && 
                            p[color=#555555] = population[j+1]; 
          } 
    } 
/* once a new population is created, copy it back */ 
 
for (i = 0; i [color=#555555] = newpopulation; 
} 
 
/***************************************************************/ 
/* Crossover selection: selects two parents that take part in  */ 
/* the crossover. Implements a single point crossover          */ 
/***************************************************************/ 
 
void crossover(void) 
{ 
int i, mem, one; 
int first  =  0; /* count of the number of members chosen */ 
double x; 
 
for (mem = 0; mem  1) 
{ 
if(NVARS == 2) 
       point = 1; 
else 
       point = (rand() % (NVARS - 1)) + 1; 
 
for (i = 0; i [color=#555555], &population[two].gene); 
 
} 
} 
 
/*************************************************************/ 
/* Swap: A swap procedure that helps in swapping 2 variables */ 
/*************************************************************/ 
 
void swap(double *x, double *y) 
{ 
double temp; 
 
temp = *x; 
*x = *y; 
*y = temp; 
 
} 
 
/**************************************************************/ 
/* Mutation: Random uniform mutation. A variable selected for */ 
/* mutation is replaced by a random value between lower and   */ 
/* upper bounds of this variable                              */ 
/**************************************************************/ 
 
void mutate(void) 
{ 
int i, j; 
double lbound, hbound; 
double x; 
 
for (i = 0; i [color=#555555].lower[j]; 
                hbound = population.upper[j]; 
                population.gene[j] = randval(lbound, hbound); 
                } 
          } 
} 
 
/***************************************************************/ 
/* Report function: Reports progress of the simulation. Data   */ 
/* dumped into the  output file are separated by commas        */ 
/***************************************************************/ 
 
void report(void) 
{ 
int i; 
double best_val;            /* best population fitness */ 
double avg;                 /* avg population fitness */ 
double stddev;              /* std. deviation of population fitness */ 
double sum_square;          /* sum of square for std. calc */ 
double square_sum;          /* square of sum for std. calc */ 
double sum;                 /* total population fitness */ 
 
sum = 0.0; 
sum_square = 0.0; 
 
for (i = 0; i [color=#555555].fitness; 
    sum_square += population.fitness * population.fitness; 
    } 
 
avg = sum/(double)POPSIZE; 
square_sum = avg * avg * POPSIZE; 
stddev = sqrt((sum_square - square_sum)/(POPSIZE - 1)); 
best_val = population[POPSIZE].fitness; 
 
fprintf(galog, "n%5d,      %6.3f, %6.3f, %6.3f nn", generation, 
                                    best_val, avg, stddev); 
} 
 
/**************************************************************/ 
/* Main function: Each generation involves selecting the best */ 
/* members, performing crossover & mutation and then          */ 
/* evaluating the resulting population, until the terminating */ 
/* condition is satisfied                                     */ 
/**************************************************************/ 
 
void main(void) 
{ 
int i; 
 
if ((galog = fopen("galog.txt","w"))==NULL) 
    { 
    exit(1); 
    } 
generation = 0; 
 
fprintf(galog, "n generation  best  average  standard n"); 
fprintf(galog, " number      value fitness  deviation n"); 
 
initialize(); 
evaluate(); 
keep_the_best(); 
while(generation[color=#555555]); 
} 
fprintf(galog,"nn Best fitness = %3.3f",population[POPSIZE].fitness); 
fclose(galog); 
printf("Successn"); 
} 
/***************************************************************/

赞回复

vfdff(作者)

2010-08-08 10:04

14

#include <stdio.h> 
/* 把 n 用m 进制显示 */ 
 
 
// #include <WATLIB.H> 测试表明lib库不通用 
#include <bitset> 
#include <vcLIB.H> 
typedef  char BOOL ; 
typedef  unsigned char UCHAR8 ; 
 
#define  NUM  10 
 
void PN(int n,int m)  /* 把 n 用m 进制显示 */ 
{ 
    char temp[10]={0}; 
    int i=0; 
    do { 
        temp = n%m; 
        i++; 
        n /= m; 
    }while(n>0); 
    for(i -= 1;i>=0;i--){ 
        printf("%x",temp); 
    } 
} 
 
int main() 
{ 
    int i= 3; 
        bitset< 32 > bitvec = 4; 
        printf("%x",bitvec.set()); 
 
    return 0; 
}

赞回复