纯C，使用遗传算法对病态线性方程组求解AX=B

使用遗传算法对病态线性方程组求解

对于什么是遗传算法，在松鼠科学会上有一篇有趣的文章
遗传算法构建firefox图标

遗传算法 的大致框架如下图所示
下面的长代码有什么用呢？
它使用算法遗传解决了

AX=B

的问题

我就觉得效率不是很高，使用起来有很大的不便。

什么是遗传算法呢？

简单地说，遗传算法是一种解决问题的方法。它模拟大自然中种群在选择压力下的演化，从而得到问题的一个近似解。

将以下数据放入A.txt,B.txt
将上述文件放入程序文件同目录

A的数据

(1, 1, 1)
(2, 8, -1)
(2, 3, -1)
(2, 2, 4)
(3, 9, -1)
(3, 2, -1)
(3, 3, 4)
(4, 4, 1)
(5, 2, -1)
(5, 6, -1)
(5, 5, 4)
(6, 2, -1)
(6, 5, -1)
(6, 6, 4)
(7, 7, 1)
(8, 6, -1)
(8, 9, -1)
(8, 8, 4)
(9, 5, -1)
(9, 8, -1)
(9, 9, 4)
(10, 10, 1)
(11, 7, -1)
(11, 12, -1)
(11, 11, 4)
(12, 2, -1)
(12, 11, -1)
(12, 12, 4)

B的数据

(1, 1, 2)
(2, 1, 5)
(3, 1, 4)
(4, 1, 2)
(5, 1, 5)
(6, 1, 4)
(7, 1, 2)
(8, 1, 7)
(9, 1, 3)
(10, 1, 4)
(11, 1, 0)
(12, 1, 4）

X的结果

2.039260
2.469905
2.118222
2.037000
2.412758
2.226262
2.044251
2.806577
2.044782
4.032598
1.827159
5.236275

使用以下代码前需要把第6行和第10行的opencv库调用删除，如果没有把opencv的库装到某些奇怪的地方的话。
此代码共计600行阅读可能存在一定的困难

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<stdlib.h>
#include<opencv.hpp>
#include <iostream>
#include <time.h>
#define _CRT_SECURE_NO_WARNINGS
using namespace cv;
#define SUM 200   //总共的染色体数量
#define MAXloop  2000000//最大循环次数
#define error 10   //若两次最优值之差小于此数则认为结果没有改变
#define crossp 0.1      //交叉概率
#define mp 0.4           //变异概率
#define length 12
float X[length+1];
//#define d 0
float a[length+1];
typedef struct NODE//稀疏方程组数据
{
   
	int row;
	int col;
	int date;
	struct NODE* next;
}node;
//   Ax = b    x的各元素在（0,255）之间的最小值 
struct gen                //定义染色体结构X
{
   
	float  info[length+1];        		//染色体结构 //表示length 个(0,255)的整数
	float  suitability;		//次染色体所对应的适应度函数值，在本题中为f(x)=|AX-B|的无穷范数 理想状态应该是1 选择时最大的  我们把它设置成整数就是f(x)的值
};
struct gen gen_group[SUM];//定义一个含有20个染色体的组
struct gen gen_new[SUM];
struct gen gen_yi[SUM];
struct gen gen_result;    //记录最优的染色体
int result_unchange_time=0; //记录在error前提下最优值为改变的循环次数
struct log                //形成链表，记录每次循环所产生的最优的适应度
{
   
	int suitability;
	struct log* next;
}llog, * head, * end;
int randNext(int left, int right);
int randsign(float p)//按概率p返回1
{
   
	if (randNext(0,32768) > (p * 32768))//32768是INT的最大值 
		return 0;
	else return 1;
}
int log_num;              //链表长度
node * head1, * head2;
void initiate();          	//初始化函数，主要负责产生初始化种群 
void evaluation(int flag);	//评估种群中各染色体的适应度，并据此进行排序 
void cross();				//交叉函数 
void selection(int x);			//选择函数 
int  record();				//记录每次循环产生的最优解并判断是否终止循环 
void mutation();			//变异函数 
float f(gen G);

void initiate()//初始化 
{
   
	int i;
	int j;
	for (i = 0; i < SUM; i++)
	{
   
		for (j = 1; j <= length; j++) {
   
				gen_group[i].info[j] =1.0* randNext(0,500000)/10000.0;//从1开始
		}
	}
	gen_result.suitability = 10;//最优解.对应的函数值 
}
//返回[left, right]的随机数
int randNext(int left, int right)
{
   
	static unsigned int seed = 0;
	seed++;
	srand((unsigned)time(NULL) + seed * seed);
	return rand() % (right - left + 1) + left;
}
int ff(int x,int y) {
   //防止近亲交配
	int count = 0;
	int i, j;
	for (i = 1;i <= length;i++) {
   
		if (1.0*gen_group[x].info[i] - 1.0*gen_group[y].info[i]<=0.1&& 1.0*gen_group[x].info[i] - 1.0*gen_group[y].info[i] >=- 0.1) {
   
			count++;
		}
	}
	if (count == length) {
   
		return 1;
	}
	else {
   
		return 0;
	}
}
void cross()	//交叉函数 交叉变异 交叉公式为x3=A * x1 +(1-A) * x2
{
   
	int i, j, k;
	int c;
	float A;
	//int mask1, mask2;
	int a[SUM];//sum=20 
	//printf("55");
	for (i = 0; i < SUM; i++)  a[i] = 0;//记录是否交叉过 0-19
	k = 0;		
	int x = 0;
	int s;
	for (i = 0; i < SUM; i++)
	{
   
		if (a[i] == 0)
		{
   
			j = randNext(i + 1, SUM - 1);
				while (ff(i,j)||a[j]!=0) {
   
					j = randNext(i + 1, SUM - 1);//产生一个在i+1，sum-1两个数之间的随机整数
				}
				//if (a[j] == 0)	break; //直到选择到未交叉过的
				A = (1.0*gen_group[i].suitability/(gen_group[i].suitability*1.0+1.0*gen_group[j].suitability));
				x = int(A * 1.0*length);
			if (randsign(crossp) == 1)		//按照crossp的概率对选择的染色体进行交叉操作 返回0或1   其值为1的概率为crossp  算数交换
			{