当前位置：文档之家 › 3个神经网络代码

3个神经网络代码

  • 格式：docx
  • 大小：27.14 KB
  • 文档页数：18

LOGICNERVECELL *NN::findNerveCell(U2 n) /*tmpnc 指向找到的神经元的前一个 *nc指向找到的那个*/{LOGICNERVECELL *tmpnc;if(*nc->nc->nerve_cell_num == n){return(*tmpnc);}else if(*nv->next == NULL){*nc = frist_nc; /*重新指向第一个*/return(NULL);}else{tmpnc = *nc;*nc = *nc->next;findNerveCell(n);}return(NULL);}NN::NN(U2 init){INIT = init;n_cell = INIT;recycle_cell = 0;recycle = (LOGICNERVECELL *)(malloc(sizeof(LOGICNERVECELL))*MAX_RECYCLE);/*================================================================*/*nc = (LOGICNERVECELL *)(malloc(sizeof(LOGICNERVECELL)));*nc->nc = (NERVECELL*)(malloc(sizeof(NERVECELL)));*nc->nc->nerve_cell_num = 1;*nc->nc->input = NULL;*nc->nc->output = NULL;frist_nc = *nc;for(int i=2;i<=n_cell;i++){*nc->next = (LOGICNERVECELL *)(malloc(sizeof(LOGICNERVECELL)));*nc->next->nc = (NERVECELL*)(malloc(sizeof(NERVECELL)));if(i==(n_cell)){*nc->next->nc->nerve_cell_num = i;*nc->next->nc->input = NULL;*nc->next->nc->output = NULL;*nc->next = NULL;}else{*nc->next->nc->nerve_cell_num = i;*nc->next->nc->input = NULL;*nc->next->nc->output = NULL;*nc = *nc->next;}}frist_nc = *nc; /*重新指想第一个神经元*/}NN::~NN(){//释放所有占用的内寸}void NN::addNerveCellByNum(U2 n) /*n为增加多少个*/{for(int i=1;i<=n;i++){*nc->next = (LOGICNERVECELL *)(malloc(sizeof(LOGICNERVECELL))); *nc->next->nc = (NERVECELL*)(malloc(sizeof(NERVECELL)));if(i==n){*nc->next->nc->nerve_cell_num = n_cell;*nc->next->nc->input = NULL;*nc->next->nc->output = NULL;*nc->next = NULL;}else{*nc->next->nc->nerve_cell_num = i+n_cell;*nc->next->nc->input = NULL;*nc->next->nc->output = NULL;*nc = *nc->next;}}*nc = frist_nc; /*重新指想第一个神经元*/n_cell = n_cell+n;return;}//**************基于BP的ANN类*******************// --Feathersky//***********************************************#ifndef ANN_BP_H#define ANN_BP_H#include "math.h"#include <stdlib.h>#include <iostream.h>#include <fstream.h>#include <iomanip.h>#include"MemoryTool1.h"//-------------------------------------------------------------------------------class ANN_BP{public:int nMethod; //动量项标志double Rate; //学习率int layer1; //输入层结点数int layer2; //中间层结点数int layer3; //输出层结点数double *Y1; //第一层输出double *Y2; //第二层输出double *Y3; //第三层输出double *Dest; //期望输出double **W1; //权值矩阵double **W2;double **SW1; //第一层权值的改变量动量项作法使用double **SW2; //第二层权值的改变量动量项作法使用double *S3; //辅助变量double *S2; //辅助变量double **G1_1; //第一层权值距阵各分量偏导double **G2_1; //第二层权值距阵各分量偏导public:// 类构造函数，输入参数为3层BP网络每层的结点数。

// 在此函数中进行内存分配等初始化工作ANN_BP(){Y1=Y2=Y3=Dest=NULL;W1=W2=NULL;SW1=SW2=NULL;S3=S2=NULL;G1_1=G2_1=NULL;SetMethod();}ANN_BP(int input,int middle,int output){SetLayerNodeCount(input,middle,output);SetMethod();}// 类析构函数释放分配的内存~ANN_BP(){FreeMemory();}void FreeMemory(){delete[] Y1;delete[] Y2;delete[] Y3;delete[] Dest;free2D(W1);free2D(W2);free2D(SW1);free2D(SW2);delete[] S2;delete[] S3;free2D(G1_1);free2D(G2_1);}void SetLayerNodeCount(int input,int middle,int output) {FreeMemory();layer1=input+1; //输入层结点数layer2=middle; //中间层结点数layer3=output; //输出层结点数Y1 = new double[layer1];Y2 = new double[layer2];Y3 = new double[layer3];Dest= new double[layer3];W1 =malloc2D(layer2,layer1);W2 =malloc2D(layer3,layer2);SW1 =malloc2D(layer2,layer1);SW2 =malloc2D(layer3,layer2);S2 = new double[layer2];S3 = new double[layer3];G1_1 =malloc2D(layer2,layer1);G2_1 =malloc2D(layer3,layer2);initial();}void SetMethod(int method=0){nMethod=method; //是否使用动量项标志}private://用随机数初始化权值void initial(){for(int i=0;i<layer1;i++)for(int j=0;j<layer2;j++){W1[i][j]=(double)(rand()%2000-1000)/1000;if(W1[i][j]==0) W1[i][j]=0.1;}for( i=0;i<layer2;i++)for(int j=0;j<layer3;j++){W2[i][j]=(double)(rand()%2000-1000)/1000;if(W2[i][j]==0) W2[i][j]=0.1;}}int sgn(double i){if(i>0) return1;if(i<0) return -1;return0;}//sigmoid 函数double func(double i){// return (double)( (1-exp(-i))/(1+exp(-i)) );if(i<-45) return0;if(i>45) return1;return 1.0/(1.0+exp(-i));}/*我在程序中调试，曾遇见过此类溢出，故此技巧是必须的Subject: How to avoid overflow in the logistic function?The formula for the logistic activation function is often wri tten as:netoutput = 1 / (1+exp(-netinput));But this formula can produce floating-point overflow in the e xponential function if you program it in this simple form. To avo id overflow, you can do this:if (netinput < -45) netoutput = 0;else if (netinput > 45) netoutput = 1;else netoutput = 1 / (1+exp(-netinput));The constant 45 will work for double precision on all machine s that I know of, but there may be some bizarre machines where it will require some adjustment. Other activation functions can be handled similarly.*/void ComputeY() // 计算各层输出Y1[], Y2[],Y3[]{int i;for(i=0; i<layer2; i++){Y2[i]=0;for(int j=0;j<layer1;j++) Y2[i]+=Y1[j]*W1[j][i]; Y2[i]=func(Y2[i]);}for(i=0; i<layer3; i++){Y3[i]=0;for(int j=0;j<layer2;j++) Y3[i]+=Y2[j]*W2[j][i];Y3[i]=func(Y3[i]);}}void ComputeG() //计算误差对各层矩阵的偏导，求得梯度信息{int i,j;for(i=0;i<layer3;i++){S3[i]=(Dest[i]-Y3[i])*(1-Y3[i])*Y3[i];}for(i=0;i<layer2;i++){S2[i]=0;for(int j=0;j<layer3;j++) S2[i]+=W2[i][j]*S3[j];S2[i]*=(1-Y2[i]) * Y2[i];}for( i=0;i<layer1;i++ )for( j=0;j<layer2;j++ )G1_1[i][j]=Y1[i]*S2[j];for( i=0;i<layer2;i++ )for( j=0;j<layer3;j++ )G2_1[i][j]=Y2[i]*S3[j];}void WeightAdapt() // 按梯度方向修正权值{if(nMethod==0) //不使用动量项改进{for(int i=0;i<layer2;i++)for(int j=0;j<layer3;j++){W2[i][j]+=Rate*G2_1[i][j]; }for(i=0;i<layer1;i++)for(int j=0;j<layer2;j++){W1[i][j]+=Rate*G1_1[i][j];}}if(nMethod==1) //使用动量项改进此方式只有对一个样本训练的次数大于1时有用{for(int i=0;i<layer2;i++)for(int j=0;j<layer3;j++){W2[i][j]+=Rate*G2_1[i][j]+0.5*Rate*SW2[i][j];SW2[i][j]=Rate*G2_1[i][j];}for(i=0;i<layer1;i++)for(int j=0;j<layer2;j++){W1[i][j]+=Rate*G1_1[i][j]+0.5*Rate*SW1[i][j];SW1[i][j]=Rate*G1_1[i][j];}}}public://LimitTrainCount 最大训练次数//Error 允许学习误差double TrainOneCase(double Input[],double Out[],double Error= 0.000001,int LimitTrainCount=500){int w,h;if(nMethod==1){for( h=0; h<layer1; h++)for( w=0; w<layer2; w++){SW1[h][w]=0; //动量项置为0}for( h=0; h<layer2; h++)for( w=0; w<layer3; w++){SW2[h][w]=0; //动量项置为0}}Y1[layer1-1]=-1; //域值对应的输入for(int i=0;i<layer1-1;i++) Y1[i] = Input[i];for( i=0;i<layer3;i++) Dest[i] = Out[i];double TrainError;Rate=0.3;do{if(--LimitTrainCount<0) break;ComputeY();ComputeG();WeightAdapt();TrainError=0;for(i=0; i<layer3; i++) TrainError+=(Dest[i]-Y3[i] )*(Dest[i]-Y3[i])/2;Rate=0.05+TrainError/5; //根据误差自适应修改学习率}while(TrainError>Error); // 误差指标return TrainError; //返回误差}double ComputeError(double Input[],double Out[]){double TrainError=0;Y1[layer1-1]=-1;for(int i=0;i<layer1-1;i++) Y1[i] = Input[i];for( i=0;i<layer3;i++) Dest[i] = Out[i];ComputeY();for(i=0; i<layer3; i++) TrainError+=(Dest[i]-Y3[i])*(D est[i]-Y3[i])/2;return TrainError; //返回误差}//Out[]即为输出结果int DecideOneCase(double Input[],double Out[]){Y1[layer1-1]=-1;for(int i=0;i<layer1-1;i++) Y1[i] = Input[i];ComputeY();double max=0;int index=0;for(i=0;i<layer3; i++ ){Out[i]=Y3[i];if(Y3[i]>max){max=Y3[i];index=i;}}return index; //index 为out[]中最大的那个数的索引}/********************************************保存机制仅保存权重/*******************************************/int SaveWeight(char* file) //save the value of weight{ofstream in(file);in.precision(32);in<<layer1-1<<' '<<layer2<<' '<<layer3<<endl;for(int i=0;i<layer1;i++){for(int j=0;j<layer2;j++) in<<setw(64)<<W1[i][j]<< ' ';in<<endl;}in<<endl;for(i=0;i<layer2;i++){for(int j=0;j<layer3;j++) in<<setw(64)<<W2[i][j]<< ' ';in<<endl;}in.close();return1;}int LoadWeight(char * file) //load the value of weight{//CFileFind finder;//if(!finder.FindFile(file)) { initial(); return; } int input, middle, output;ifstream out(file);//out.precision(32);if(out.fail() || out.eof()) return0;out>>input>>middle>>output;SetLayerNodeCount(input,middle,output);for(int i=0;i<layer1;i++)for(int j=0;j<layer2;j++)out>>W1[i][j];for(i=0;i<layer2;i++)for(int j=0;j<layer3;j++)out>>W2[i][j];out.close();return1;}};#endif//--------------------二维数据内存管理----Feathersky-----------------------------------------------/*************************************************二维数据内存空间每行以DWORD方式对齐二位数据内存空间是连续的每行首地址另存于一数组**************************************************/#ifndef MEMORYTOOL1_H#define MEMORYTOOL1_H#include <malloc.h>/**************************************************************** ************* Funciton: malloc2D* Puroose: 分配二维数据内存空间***************************************************************** ***********/double ** malloc2D(int nW, int nH){double ** pLineHead=(double **)malloc(nH*sizeof(double *));double * pMem=(double *)malloc(nW*nH*sizeof(double));for(int i=0; i<nH; i++){pLineHead[i]=(double *)((BYTE *)pMem+nW*i*sizeof(double)) ;}return pLineHead;}/**************************************************************** ************* Funciton: Free2D* Puroose: 释放二维数据内存空间***************************************************************** ***********/inline void free2D(double ** & pLineHead){if(pLineHead){free(pLineHead[0]);free(pLineHead);}}#endif#include <cmath>#include <cstdlib>#include <cstdio>#include <ctime>//Rumelhart,1985,only one hidden layerconst double lr = 0.1;const double goal = 1e-1;const size_t SampleNum = 4;const size_t HidNeuron = 10;const size_t Input = 2;const size_t Output = 1;double Weight1[Input][HidNeuron] = {0};double Bias1[HidNeuron] = {0};double Weight2[HidNeuron][Output] = {0};double Bias2[Output] = {0};double InputValue[SampleNum][Input] ={0};double OutputValue[SampleNum][Output] ={0}; double Error[SampleNum][Output] = {0};double MSE = 1;void InitWeight(){size_t i,j;for( i=0; i<Input; i++){for(j=0; j<HidNeuron; j++){Weight1[i][j] = (rand()/(double)RAND_MAX)*2 - 1; }}for( i=0; i<HidNeuron; i++)Bias1[i] = (rand()/(double)RAND_MAX)*2 - 1;for( i=0; i<HidNeuron; i++){for(j=0; j<Output; j++){Weight2[i][j] = (rand()/(double)RAND_MAX)*2 - 1; }}for( i=0; i<Output; i++)Bias2[i] = (rand()/(double)RAND_MAX)*2 - 1;}double LogSigmoid(double x){return 1/(1+exp(-x));}double DetLogSigmoid(double x){return LogSigmoid(x) - pow(LogSigmoid(x),2.0); }void Computing(){size_t i,j,k;double sum=0;double hidOutput[SampleNum][HidNeuron] = {0}; double finOutput[SampleNum][Output] = {0};double detOutput[Output] = {0};double detHid[HidNeuron] = {0};double simHidError[HidNeuron] ={0};for(i=0; i<SampleNum; i++){//ForwardComputingfor(j=0; j<HidNeuron; j++){sum =0;for(k=0; k<Input+1; k++){if(k == Input)sum += (-1)*Bias1[j];elsesum += InputValue[i][k]*Weight1[k][j];}hidOutput[i][j] = LogSigmoid(sum);}for(j=0; j<Output; j++){sum =0;for(k=0; k<HidNeuron+1; k++){if(k == HidNeuron)sum += (-1)*Bias2[j];elsesum += hidOutput[i][k]*Weight2[k][j];}finOutput[i][j] = LogSigmoid(sum);Error[i][j] = OutputValue[i][j] - finOutput[i][j];}//BackwardComputingfor(j=0; j<Output; j++){detOutput[j] = finOutput[i][j]*(1-finOutput[i][j])*Error[i][j]; for(k=0; k<HidNeuron; k++){Weight2[k][j] += (lr*detOutput[j]*hidOutput[i][k]);}Bias2[j] += (lr*detOutput[j]*(-1));}for(j=0; j<HidNeuron; j++){simHidError[j] = 0;for(k=0; k<Output; k++){simHidError[j] += detOutput[k]*Weight2[j][k];}}for(j=0; j<HidNeuron; j++){detHid[j] = hidOutput[i][j]*(1-hidOutput[i][j])*simHidError[j]; for(k=0; k<Input; k++){Weight1[k][j] += (lr*detHid[j]*InputValue[i][k]);}Bias1[j] += (lr*detHid[j]*(-1));}}MSE=0;for(i =0; i<Output; i++){for(j=0; j<SampleNum; j++){MSE += (Error[j][i]*Error[j][i]);}}MSE = sqrt(MSE/SampleNum);}int main(){srand(unsigned(time(NULL)));static clock_t BeforeRunTime = clock(); InitWeight();InputValue[0][0] = 0;InputValue[0][1] = 0;OutputValue[0][0] = 0;InputValue[1][0] = 1;InputValue[1][1] = 1;OutputValue[1][0] = 0;InputValue[2][0] = 0;InputValue[2][1] = 1;OutputValue[2][0] = 1;InputValue[3][0] = 1;InputValue[3][1] = 0;OutputValue[3][0] = 1;size_t cEpoch = 0;while(MSE>goal){cEpoch++;Computing();printf("MSE: %.6f\n",MSE);}printf("Epochs %d\n",cEpoch);clock_t UsedTime = clock()-BeforeRunTime; printf("UsedTime %dms\n",UsedTime);getchar();return 0;}。

合集下载

基于遗传算法的BP神经网络MATLAB代码

基于遗传算法的BP神经网络MATLAB代码

基于遗传算法的BP神经网络MATLAB代码以下是基于遗传算法的BP神经网络的MATLAB代码，包括网络初始化、适应度计算、交叉运算、突变操作和迭代训练等。

1.网络初始化:```matlabfunction net = initialize_network(input_size, hidden_size, output_size)net.input_size = input_size;net.hidden_size = hidden_size;net.output_size = output_size;net.hidden_weights = rand(hidden_size, input_size);net.output_weights = rand(output_size, hidden_size);net.hidden_biases = rand(hidden_size, 1);net.output_biases = rand(output_size, 1);end```2.适应度计算:```matlabfunction fitness = calculate_fitness(net, data, labels)output = forward_propagation(net, data);fitness = sum(sum(abs(output - labels)));end```3.前向传播:```matlabfunction output = forward_propagation(net, data)hidden_input = net.hidden_weights * data + net.hidden_biases;hidden_output = sigmoid(hidden_input);output_input = net.output_weights * hidden_output +net.output_biases;output = sigmoid(output_input);endfunction result = sigmoid(x)result = 1 ./ (1 + exp(-x));end```4.交叉运算:```matlabfunction offspring = crossover(parent1, parent2)point = randi([1 numel(parent1)]);offspring = [parent1(1:point) parent2((point + 1):end)]; end```5.突变操作:```matlabfunction mutated = mutation(individual, mutation_rate) for i = 1:numel(individual)if rand < mutation_ratemutated(i) = rand;elsemutated(i) = individual(i);endendend```6.迭代训练:```matlabfunction [best_individual, best_fitness] =train_network(data, labels, population_size, generations, mutation_rate)input_size = size(data, 1);hidden_size = round((input_size + size(labels, 1)) / 2);output_size = size(labels, 1);population = cell(population_size, 1);for i = 1:population_sizepopulation{i} = initialize_network(input_size, hidden_size, output_size);endbest_individual = population{1};best_fitness = calculate_fitness(best_individual, data, labels);for i = 1:generationsfor j = 1:population_sizefitness = calculate_fitness(population{j}, data, labels);if fitness < best_fitnessbest_individual = population{j};best_fitness = fitness;endendselected = selection(population, data, labels);for j = 1:population_sizeparent1 = selected{randi([1 numel(selected)])};parent2 = selected{randi([1 numel(selected)])};offspring = crossover(parent1, parent2);mutated_offspring = mutation(offspring, mutation_rate);population{j} = mutated_offspring;endendendfunction selected = selection(population, data, labels) fitnesses = zeros(length(population), 1);for i = 1:length(population)fitnesses(i) = calculate_fitness(population{i}, data, labels);end[~, indices] = sort(fitnesses);selected = population(indices(1:floor(length(population) / 2)));end```这是一个基于遗传算法的简化版BP神经网络的MATLAB代码，使用该代码可以初始化神经网络并进行迭代训练，以获得最佳适应度的网络参数。

eegnet代码

eegnet代码

eegnet代码
EEGNet是一个用于脑电信号分类的深度学习架构，该架构具有出色的性能和低计算量的特点。

它使用了1D卷积神经网络(CNNs)，以利用来自时间序列数据的局部结构特征，并通过降低参数的数量来实现更快的训练和更高的准确性。

EEGNet代码包含三个主要文件：eegnet.py，
cnn_utils.py和data_utils.py。

eegnet.py包含EEGNet类，该类定义了EEGNet架构，其中包括一个1D CNN，批归一化层和全连接层。

cnn_utils.py包括一些辅助函数，用于在构建网络模型时使用，例如weight_variable()、bias_variable()和conv1d()。

data_utils.py包括一些函数，用于加载脑电信号数据集，并将其转换为与EEGNet架构兼容的格式。

神经网络（NeuralNetwork）

神经网络（NeuralNetwork）

神经⽹络（NeuralNetwork）⼀、激活函数激活函数也称为响应函数，⽤于处理神经元的输出，理想的激活函数如阶跃函数，Sigmoid函数也常常作为激活函数使⽤。

在阶跃函数中，1表⽰神经元处于兴奋状态，0表⽰神经元处于抑制状态。

⼆、感知机感知机是两层神经元组成的神经⽹络，感知机的权重调整⽅式如下所⽰：按照正常思路w i+△w i是正常y的取值，w i是y'的取值，所以两者做差，增减性应当同(y-y')x i⼀致。

参数η是⼀个取值区间在(0,1)的任意数，称为学习率。

如果预测正确，感知机不发⽣变化，否则会根据错误的程度进⾏调整。

不妨这样假设⼀下，预测值不准确，说明Δw有偏差，⽆理x正负与否，w的变化应当和(y-y')x i⼀致，分情况讨论⼀下即可，x为负数，当预测值增加的时候，权值应当也增加，⽤来降低预测值，当预测值减少的时候，权值应当也减少，⽤来提⾼预测值；x为正数，当预测值增加的时候，权值应当减少，⽤来降低预测值，反之亦然。

(y-y')是出现的误差，负数对应下调，正数对应上调，乘上基数就是调整情况，因为基数的正负不影响调整情况，毕竟负数上调需要减少w的值。

感知机只有输出层神经元进⾏激活函数处理，即只拥有⼀层功能的神经元，其学习能⼒可以说是⾮常有限了。

如果对于两参数据，他们是线性可分的，那么感知机的学习过程会逐步收敛，但是对于线性不可分的问题，学习过程将会产⽣震荡，不断地左右进⾏摇摆，⽽⽆法恒定在⼀个可靠地线性准则中。

三、多层⽹络使⽤多层感知机就能够解决线性不可分的问题，输出层和输⼊层之间的成为隐层/隐含层，它和输出层⼀样都是拥有激活函数的功能神经元。

神经元之间不存在同层连接，也不存在跨层连接，这种神经⽹络结构称为多层前馈神经⽹络。

换⾔之，神经⽹络的训练重点就是链接权值和阈值当中。

四、误差逆传播算法误差逆传播算法换⾔之BP(BackPropagation)算法，BP算法不仅可以⽤于多层前馈神经⽹络，还可以⽤于其他⽅⾯，但是单单提起BP算法，训练的⾃然是多层前馈神经⽹络。

神经网络文字识别关键代码

神经网络文字识别关键代码

神经网络文字识别关键代码下面作者列出bp网络训练及识别的完整源代码bp.h。

#include <stdio.h>#include <math.h>#include <time.h>#include <stdlib.h>#define BIGRND 32767/************************函数声明部分*****************************///随机数产生函数double drnd();double dpn1();//S函数double squash(double x);//分配1维double型的内存double *alloc_1d_dbl(int n);//分配2维double型的内存double **alloc_2d_dbl(int m, int n);//初始化BP网络void bpnn_initialize(int seed);//随机初始化权值void bpnn_randomize_weights(double **w, int m, int n);//零初始化权值void bpnn_zero_weights(double **w, int m, int n);//信息的前向传输void bpnn_layerforward(double *l1, double *l2, double **conn, int n1, int n2);//误差输出void bpnn_output_error(double *delta, double *target, double *output, int nj);//隐层误差void bpnn_hidden_error(double* delta_h, int nh, double *delta_o, int no, double **who, double *hidden);//根据误差调整权值void bpnn_adjust_weights(double *delta, int ndelta, double *ly, int nly, double** w, double **oldw, double eta, double momentum);//保存权值void w_weight(double **w,int n1,int n2,char*name);//读取权值bool r_weight(double **w,int n1,int n2,char *name);//保存Bp网络各层结点数目void w_num(int n1,int n2,int n3,char*name);//读取Bp网络各层结点数目bool r_num(int *n,char *name);//特征提取void code(BYTE*image ,int *p,int w,int h,int dw);//BP网络训练void BpTrain(HDIB hDIB,int n_hidden,double min_ex,double momentum,double eta ,int width,int height);//利用BP网络进行识别void CodeRecognize(HDIB hDIB,int width ,int height ,int n_in ,int n_hidden,int n_out);/**********************************************************************/ /****************** 以下是函数的实现部分***********************************//*** 返回0－1的双精度随机数 ***/double drnd(){//BIGRND定义为随机数的最大范围return ((double) rand() / (double) BIGRND);}/*** 返回-1.0到1.0之间的双精度随机数 ***/double dpn1(){return ((drnd() * 2.0) - 1.0);}double squash(double x){//返回S激活函数return (1.0 / (1.0 + exp(-x)));}/*** 申请1维双精度实数数组 ***/double *alloc_1d_dbl(int n){double *new1;//申请内存new1 = (double *) malloc ((unsigned) (n * sizeof (double)));//申请内存失败处理if (new1 == NULL) {printf("ALLOC_1D_DBL: Couldn't allocate array of doubles\n");return (NULL);}//返回申请到的内存的指针return (new1);}/*** 申请2维双精度实数数组 ***/double **alloc_2d_dbl(int m, int n){int i;//定义一二维指针double **new1;//先申请一维内存new1 = (double **) malloc ((unsigned) (m * sizeof (double *)));//申请失败处理if (new1 == NULL) {// printf("ALLOC_2D_DBL: Couldn't allocate array of dbl ptrs\n");return (NULL);}//再申请二维内存。