add Filter Solver for Variational Models

YuanhaoGong · YuanhaoGong · commit 67cfd2c44770 · 2015-10-14T21:38:54.000+08:00
improve the performance a little bit
diff --git a/DM.h b/DM.h
@@ -33,7 +33,7 @@ class DM
     void Filter(int Type, double & time, int ItNum = 10);//with split
     void FilterNoSplit(int Type, double & time, int ItNum = 10);//direct on imgF 
     /******************* generic solver for variational models *****************************/
-    void Solver(int Type, double & time, int ItNum,  float lambda = 2, float DataFitOrder = 1);
+    void Solver(int Type, double & time, int MaxItNum,  float lambda = 2, float DataFitOrder = 1);
 
 private:
     //padded original, tmp, result
@@ -190,7 +190,6 @@ void DM::write(const char* FileName)
 //compute Total Variation
 void DM::TV(Mat & imgF, Mat & T)
 {
-    T = Mat::zeros(imgF.rows, imgF.cols, CV_32FC1);
     float * p_row, *pn_row;
     float * p_t;
     for(int i = 1; i < imgF.rows-1; i++)
@@ -226,7 +225,7 @@ void DM::MC(Mat& imgF, Mat & MC)
             Iyy = pn_row[j] -2*p_row[j] + pp_row[j];
             
             num = Ixx + Iyy;
-            den = (1.0 + Ix*Ix + Iy*Iy);
+            den = (1.0f + Ix*Ix + Iy*Iy);
             p_d[j] = num/den;
         }   
     }
@@ -254,8 +253,8 @@ void DM::GC(Mat & imgF, Mat &GC)
             Ixy = (pn_row[j-1] - pn_row[j+1]- pp_row[j-1] + pp_row[j+1])/4;
 
             num = Ixx*Iyy - Ixy*Ixy;
-            den = (1.0 + Ix*Ix + Iy*Iy);
-            den = pow(den, 1.5f);
+            den = (1.0f + Ix*Ix + Iy*Iy);
+            den = powf(den, 1.5f);
             p_d[j] = num/den;
         }   
     }
@@ -356,7 +355,7 @@ void DM::Filter(int Type, double & time, int ItNum )
     			return;
     		}
     }
-    float d;
+
     Tstart = clock();
     for(int it=0;it<ItNum;++it)
     {
@@ -496,17 +495,19 @@ void DM::FilterNoSplit(int Type, double & time, int ItNum )
 
 //generic filter solver for variational model |U - I|^DataFitOrder + lambda * Regularization
 //the DataFitOrder can be fractional such as 1.5, which is not possible for other solvers.
-void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitOrder)
+void DM::Solver(int Type, double & time, int MaxItNum, float lambda, float DataFitOrder)
 {
     clock_t Tstart, Tend;
     float (DM::* Local)(int i, float* p_pre, float* p, float* p_nex);
     void (DM::* curvature_compute)(Mat& img, Mat& curv);
 
     Mat curvature = Mat::zeros(M, N, CV_32FC1);
     Mat dataFit = Mat::zeros(M, N, CV_32FC1);
-    std::vector<float> energyRecord;
+    std::vector<double> energyRecord;
 
-    std::cout<<"Solver with Lambda = "<<lambda<<" and data fit order = "<<DataFitOrder<<endl;
+    std::cout<<"********************************************"<<endl;
+    std::cout<<"*** Filter Solver for Variational Models ***\n    Lambda = "<<lambda<<" and DataFitOrder = "<<DataFitOrder<<endl;
+    std::cout<<"********************************************"<<endl;
 
     switch(Type)
     {
@@ -543,15 +544,18 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO
     }
     
     float d, energy_increase, tmp;
+    int count = 0;
 
     Tstart = clock();
-    for(int it=0;it<ItNum;++it)
+    for(int it=0;it<MaxItNum;++it)
     {
         (this->*curvature_compute)(imgF, curvature);
 
         dataFit = imgF - image;
-
         energyRecord.push_back(lambda*energy(curvature)+DataFitEnergy(dataFit,DataFitOrder));
+        //if the energy starts to increase, stop the loop
+        if(count>1 && energyRecord[it] > energyRecord[it-1]) break;
+
         //black circle
         for (int i = 1; i < M-1; ++i,++i)
         {
@@ -563,7 +567,7 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO
             {
                 d = (this->*Local)(j,p_pre,p,p_down);
                 tmp = fabsf(p[j] - p_data[j]);
-                energy_increase = pow(tmp + d, DataFitOrder) - pow(tmp, DataFitOrder);
+                energy_increase = powf(tmp + d, DataFitOrder) - powf(tmp, DataFitOrder);
                 if (energy_increase < lambda*abs(d)) p[j] += d;
             }
         }
@@ -579,7 +583,7 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO
             {
                 d = (this->*Local)(j,p_pre,p,p_down);
                 tmp = fabsf(p[j] - p_data[j]);
-                energy_increase = pow(tmp + d, DataFitOrder) - pow(tmp, DataFitOrder);
+                energy_increase = powf(tmp + d, DataFitOrder) - powf(tmp, DataFitOrder);
                 if (energy_increase < lambda*abs(d)) p[j] += d;
             }
         }
@@ -595,7 +599,7 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO
             {
                 d = (this->*Local)(j,p_pre,p,p_down);
                 tmp = fabsf(p[j] - p_data[j]);
-                energy_increase = pow(tmp + d, DataFitOrder) - pow(tmp, DataFitOrder);
+                energy_increase = powf(tmp + d, DataFitOrder) - powf(tmp, DataFitOrder);
                 if (energy_increase < lambda*abs(d)) p[j] += d;
             }
         }
@@ -611,10 +615,11 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO
             {
                 d = (this->*Local)(j,p_pre,p,p_down);
                 tmp = fabsf(p[j] - p_data[j]);
-                energy_increase = pow(tmp + d, DataFitOrder) - pow(tmp, DataFitOrder);
+                energy_increase = powf(tmp + d, DataFitOrder) - powf(tmp, DataFitOrder);
                 if (energy_increase < lambda*abs(d)) p[j] += d;
             }
         }
+        count++;
     }
     Tend = clock() - Tstart;   
     time = double(Tend)/(CLOCKS_PER_SEC/1000.0);
@@ -626,11 +631,10 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO
     //output the total energy profile
     ofstream energyProfile;
     energyProfile.open ("TotalEnergy.txt");
-    for (int i = 0; i < ItNum; ++i)
+    for (int i = 0; i <= count; ++i)
     {
     energyProfile<<i<<" "<<energyRecord[i]<<endl;
     }
-    energyProfile<<ItNum<<" "<<energyRecord[ItNum];
     energyProfile.close();
 }
 
@@ -707,8 +711,8 @@ inline void DM::MC_one(float* __restrict p, float* __restrict p_right, float* __
      {
      	
 		dist[4] = p[j]*8;
-		dist[5] = (p_pre[j]+p_down[j])*2.5 - dist[4];
-		dist[6] = (p_right[j-1]+p_right[j])*2.5 - dist[4];
+		dist[5] = (p_pre[j]+p_down[j])*2.5f - dist[4];
+		dist[6] = (p_right[j-1]+p_right[j])*2.5f - dist[4];
 
 		dist[0] = dist[5] + p_right[j]*5 -p_Corner[j]-p_rd[j];
 		dist[1] = dist[5] + p_right[j-1]*5 -p_Corner[j-1]-p_rd[j-1];
@@ -732,8 +736,8 @@ inline void DM::MC_two(float* __restrict p, float* __restrict p_right, float* __
      {
      	
 		dist[4] = p[j]*8;
-		dist[5] = (p_pre[j]+p_down[j])*2.5 - dist[4];
-		dist[6] = (p_right[j]+p_right[j+1])*2.5 - dist[4];
+		dist[5] = (p_pre[j]+p_down[j])*2.5f - dist[4];
+		dist[6] = (p_right[j]+p_right[j+1])*2.5f - dist[4];
 
 
      	dist[0] = dist[5] + p_right[j]*5 -p_Corner[j]-p_rd[j];
@@ -909,7 +913,7 @@ inline void DM::TV_two(float* __restrict p, float* __restrict p_right, float* __
 inline void DM::DC_one(float* __restrict p, float* __restrict p_right, float* __restrict p_down, float * __restrict p_rd, float* __restrict p_pre, float* __restrict p_Corner)
 {
     register float dist[4];
-    register float weight = -0.225603;
+    register float weight = -0.225603f;
     
     for (int j = 1; j < N_half; ++j)
      {
@@ -933,7 +937,7 @@ inline void DM::DC_one(float* __restrict p, float* __restrict p_right, float* __
 inline void DM::DC_two(float* __restrict p, float* __restrict p_right, float* __restrict p_down, float * __restrict p_rd, float* __restrict p_pre, float* __restrict p_Corner)
 {
     register float dist[4];
-    register float weight = -0.225603;
+    register float weight = -0.225603f;
 
     for (int j = 0; j < N_half-1; ++j)
      {
@@ -1001,16 +1005,16 @@ inline float DM::Scheme_MC(int i, float* p_pre, float* p, float* p_nex)
 	float dist[2];
     float tmp = 8*p[i];
 
-    dist[0] = 2.5*(p_pre[i]+p_nex[i]) + 5*p[i+1] - p_pre[i+1] - p_nex[i+1] - tmp;
-    dist[1] = 2.5*(p_pre[i]+p_nex[i]) + 5*p[i-1] - p_pre[i-1] - p_nex[i-1] - tmp;
+    dist[0] = 2.5f*(p_pre[i]+p_nex[i]) + 5*p[i+1] - p_pre[i+1] - p_nex[i+1] - tmp;
+    dist[1] = 2.5f*(p_pre[i]+p_nex[i]) + 5*p[i-1] - p_pre[i-1] - p_nex[i-1] - tmp;
     if(fabsf(dist[1])<fabsf(dist[0])) dist[0] = dist[1];
 
-    dist[1] = 2.5*(p[i-1]+p[i+1]) + 5*p_nex[i] - p_nex[i-1] - p_nex[i+1] - tmp;
+    dist[1] = 2.5f*(p[i-1]+p[i+1]) + 5*p_nex[i] - p_nex[i-1] - p_nex[i+1] - tmp;
     if(fabsf(dist[1])<fabsf(dist[0])) dist[0] = dist[1];
-    dist[1] = 2.5*(p[i-1]+p[i+1]) + 5*p_pre[i]- p_pre[i-1] - p_pre[i+1] - tmp;
+    dist[1] = 2.5f*(p[i-1]+p[i+1]) + 5*p_pre[i]- p_pre[i-1] - p_pre[i+1] - tmp;
     if(fabsf(dist[1])<fabsf(dist[0])) dist[0] = dist[1];
 
-    dist[0] /= 8.0;
+    dist[0] /= 8.0f;
     
     return dist[0];
 }
@@ -1095,7 +1099,7 @@ inline float DM::Scheme_TV(int i, float* p_pre, float* p, float* p_nex)
 inline float DM::Scheme_DC(int i, float * __restrict p_pre, float * __restrict p, float * __restrict p_nex)
 {
     float dist[2];
-    float weight = -0.225603;
+    float weight = -0.225603f;
 
     dist[0] = (p_pre[i] + p_nex[i])/2 + (p_pre[i+1] + p_nex[i+1] - 2*p[i+1])*weight - p[i];
     dist[1] = (p_pre[i] + p_nex[i])/2 + (p_pre[i-1] + p_nex[i-1] - 2*p[i-1])*weight - p[i];
diff --git a/main.cpp b/main.cpp
@@ -13,8 +13,8 @@ using namespace std;
 //default filter and iteration number
 int ItNum = 10;
 int Type = 2;
-float lambda = 1;
-float DataFitOrder = 1;
+float lambda = 1.0f;
+float DataFitOrder = 1.0f;
 
 #include "DM.h"
 
@@ -30,7 +30,7 @@ int main(int argc, char** argv)
     	cout<<" --------------------------------------------------------------- \n\n";
        cout<<"usage: main imageName filterType Iterations.\n For example: ./cf lena.bmp m 30\n";
        cout<<"             or              "<<endl;
-       cout<<"usage: main imageName filterType Iterations lambda DataFitOrder.\n For example: ./cf lena.bmp m 30 0.2 2\n";
+       cout<<"usage: main imageName filterType MaxItNum lambda DataFitOrder.\n For example: ./cf lena.bmp m 30 1.2 1.5\n";
        cout<<"************************************************\n";
        cout<<"Possible Filter Type: t (Total Variation) \n";
        cout<<"                      m (Mean Curvature) \n";

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ class DM`
`33`	`33`	`void Filter(int Type, double & time, int ItNum = 10);//with split`
`34`	`34`	`void FilterNoSplit(int Type, double & time, int ItNum = 10);//direct on imgF`
`35`	`35`	`/***************** generic solver for variational models ***************************/`
`36`		`- void Solver(int Type, double & time, int ItNum, float lambda = 2, float DataFitOrder = 1);`
	`36`	`+ void Solver(int Type, double & time, int MaxItNum, float lambda = 2, float DataFitOrder = 1);`
`37`	`37`
`38`	`38`	`private:`
`39`	`39`	`//padded original, tmp, result`
`@@ -190,7 +190,6 @@ void DM::write(const char* FileName)`
`190`	`190`	`//compute Total Variation`
`191`	`191`	`void DM::TV(Mat & imgF, Mat & T)`
`192`	`192`	`{`
`193`		`- T = Mat::zeros(imgF.rows, imgF.cols, CV_32FC1);`
`194`	`193`	`float * p_row, *pn_row;`
`195`	`194`	`float * p_t;`
`196`	`195`	`for(int i = 1; i < imgF.rows-1; i++)`
`@@ -226,7 +225,7 @@ void DM::MC(Mat& imgF, Mat & MC)`
`226`	`225`	`Iyy = pn_row[j] -2*p_row[j] + pp_row[j];`
`227`	`226`
`228`	`227`	`num = Ixx + Iyy;`
`229`		`- den = (1.0 + IxIx + IyIy);`
	`228`	`+ den = (1.0f + IxIx + IyIy);`
`230`	`229`	`p_d[j] = num/den;`
`231`	`230`	`}`
`232`	`231`	`}`
`@@ -254,8 +253,8 @@ void DM::GC(Mat & imgF, Mat &GC)`
`254`	`253`	`Ixy = (pn_row[j-1] - pn_row[j+1]- pp_row[j-1] + pp_row[j+1])/4;`
`255`	`254`
`256`	`255`	`num = IxxIyy - IxyIxy;`
`257`		`- den = (1.0 + IxIx + IyIy);`
`258`		`- den = pow(den, 1.5f);`
	`256`	`+ den = (1.0f + IxIx + IyIy);`
	`257`	`+ den = powf(den, 1.5f);`
`259`	`258`	`p_d[j] = num/den;`
`260`	`259`	`}`
`261`	`260`	`}`
`@@ -356,7 +355,7 @@ void DM::Filter(int Type, double & time, int ItNum )`
`356`	`355`	`return;`
`357`	`356`	`}`
`358`	`357`	`}`
`359`		`- float d;`
	`358`	`+`
`360`	`359`	`Tstart = clock();`
`361`	`360`	`for(int it=0;it<ItNum;++it)`
`362`	`361`	`{`
`@@ -496,17 +495,19 @@ void DM::FilterNoSplit(int Type, double & time, int ItNum )`
`496`	`495`
`497`	`496`	`//generic filter solver for variational model \|U - I\|^DataFitOrder + lambda * Regularization`
`498`	`497`	`//the DataFitOrder can be fractional such as 1.5, which is not possible for other solvers.`
`499`		`-void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitOrder)`
	`498`	`+void DM::Solver(int Type, double & time, int MaxItNum, float lambda, float DataFitOrder)`
`500`	`499`	`{`
`501`	`500`	`clock_t Tstart, Tend;`
`502`	`501`	`float (DM::* Local)(int i, float* p_pre, float* p, float* p_nex);`
`503`	`502`	`void (DM::* curvature_compute)(Mat& img, Mat& curv);`
`504`	`503`
`505`	`504`	`Mat curvature = Mat::zeros(M, N, CV_32FC1);`
`506`	`505`	`Mat dataFit = Mat::zeros(M, N, CV_32FC1);`
`507`		`- std::vector<float> energyRecord;`
	`506`	`+ std::vector<double> energyRecord;`
`508`	`507`
`509`		`- std::cout<<"Solver with Lambda = "<<lambda<<" and data fit order = "<<DataFitOrder<<endl;`
	`508`	`+ std::cout<<"********************************************"<<endl;`
	`509`	`+ std::cout<<"* Filter Solver for Variational Models *\n Lambda = "<<lambda<<" and DataFitOrder = "<<DataFitOrder<<endl;`
	`510`	`+ std::cout<<"********************************************"<<endl;`
`510`	`511`
`511`	`512`	`switch(Type)`
`512`	`513`	`{`
`@@ -543,15 +544,18 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO`
`543`	`544`	`}`
`544`	`545`
`545`	`546`	`float d, energy_increase, tmp;`
	`547`	`+ int count = 0;`
`546`	`548`
`547`	`549`	`Tstart = clock();`
`548`		`- for(int it=0;it<ItNum;++it)`
	`550`	`+ for(int it=0;it<MaxItNum;++it)`
`549`	`551`	`{`
`550`	`552`	`(this->*curvature_compute)(imgF, curvature);`
`551`	`553`
`552`	`554`	`dataFit = imgF - image;`
`553`		`-`
`554`	`555`	`energyRecord.push_back(lambda*energy(curvature)+DataFitEnergy(dataFit,DataFitOrder));`
	`556`	`+ //if the energy starts to increase, stop the loop`
	`557`	`+ if(count>1 && energyRecord[it] > energyRecord[it-1]) break;`
	`558`	`+`
`555`	`559`	`//black circle`
`556`	`560`	`for (int i = 1; i < M-1; ++i,++i)`
`557`	`561`	`{`
`@@ -563,7 +567,7 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO`
`563`	`567`	`{`
`564`	`568`	`d = (this->*Local)(j,p_pre,p,p_down);`
`565`	`569`	`tmp = fabsf(p[j] - p_data[j]);`
`566`		`- energy_increase = pow(tmp + d, DataFitOrder) - pow(tmp, DataFitOrder);`
	`570`	`+ energy_increase = powf(tmp + d, DataFitOrder) - powf(tmp, DataFitOrder);`
`567`	`571`	`if (energy_increase < lambda*abs(d)) p[j] += d;`
`568`	`572`	`}`
`569`	`573`	`}`
`@@ -579,7 +583,7 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO`
`579`	`583`	`{`
`580`	`584`	`d = (this->*Local)(j,p_pre,p,p_down);`
`581`	`585`	`tmp = fabsf(p[j] - p_data[j]);`
`582`		`- energy_increase = pow(tmp + d, DataFitOrder) - pow(tmp, DataFitOrder);`
	`586`	`+ energy_increase = powf(tmp + d, DataFitOrder) - powf(tmp, DataFitOrder);`
`583`	`587`	`if (energy_increase < lambda*abs(d)) p[j] += d;`
`584`	`588`	`}`
`585`	`589`	`}`
`@@ -595,7 +599,7 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO`
`595`	`599`	`{`
`596`	`600`	`d = (this->*Local)(j,p_pre,p,p_down);`
`597`	`601`	`tmp = fabsf(p[j] - p_data[j]);`
`598`		`- energy_increase = pow(tmp + d, DataFitOrder) - pow(tmp, DataFitOrder);`
	`602`	`+ energy_increase = powf(tmp + d, DataFitOrder) - powf(tmp, DataFitOrder);`
`599`	`603`	`if (energy_increase < lambda*abs(d)) p[j] += d;`
`600`	`604`	`}`
`601`	`605`	`}`
`@@ -611,10 +615,11 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO`
`611`	`615`	`{`
`612`	`616`	`d = (this->*Local)(j,p_pre,p,p_down);`
`613`	`617`	`tmp = fabsf(p[j] - p_data[j]);`
`614`		`- energy_increase = pow(tmp + d, DataFitOrder) - pow(tmp, DataFitOrder);`
	`618`	`+ energy_increase = powf(tmp + d, DataFitOrder) - powf(tmp, DataFitOrder);`
`615`	`619`	`if (energy_increase < lambda*abs(d)) p[j] += d;`
`616`	`620`	`}`
`617`	`621`	`}`
	`622`	`+ count++;`
`618`	`623`	`}`
`619`	`624`	`Tend = clock() - Tstart;`
`620`	`625`	`time = double(Tend)/(CLOCKS_PER_SEC/1000.0);`
`@@ -626,11 +631,10 @@ void DM::Solver(int Type, double & time, int ItNum, float lambda, float DataFitO`
`626`	`631`	`//output the total energy profile`
`627`	`632`	`ofstream energyProfile;`
`628`	`633`	`energyProfile.open ("TotalEnergy.txt");`
`629`		`- for (int i = 0; i < ItNum; ++i)`
	`634`	`+ for (int i = 0; i <= count; ++i)`
`630`	`635`	`{`
`631`	`636`	`energyProfile<<i<<" "<<energyRecord[i]<<endl;`
`632`	`637`	`}`
`633`		`- energyProfile<<ItNum<<" "<<energyRecord[ItNum];`
`634`	`638`	`energyProfile.close();`
`635`	`639`	`}`
`636`	`640`
`@@ -707,8 +711,8 @@ inline void DM::MC_one(float* __restrict p, float* __restrict p_right, float* __`
`707`	`711`	`{`
`708`	`712`
`709`	`713`	`dist[4] = p[j]*8;`
`710`		`- dist[5] = (p_pre[j]+p_down[j])*2.5 - dist[4];`
`711`		`- dist[6] = (p_right[j-1]+p_right[j])*2.5 - dist[4];`
	`714`	`+ dist[5] = (p_pre[j]+p_down[j])*2.5f - dist[4];`
	`715`	`+ dist[6] = (p_right[j-1]+p_right[j])*2.5f - dist[4];`
`712`	`716`
`713`	`717`	`dist[0] = dist[5] + p_right[j]*5 -p_Corner[j]-p_rd[j];`
`714`	`718`	`dist[1] = dist[5] + p_right[j-1]*5 -p_Corner[j-1]-p_rd[j-1];`
`@@ -732,8 +736,8 @@ inline void DM::MC_two(float* __restrict p, float* __restrict p_right, float* __`
`732`	`736`	`{`
`733`	`737`
`734`	`738`	`dist[4] = p[j]*8;`
`735`		`- dist[5] = (p_pre[j]+p_down[j])*2.5 - dist[4];`
`736`		`- dist[6] = (p_right[j]+p_right[j+1])*2.5 - dist[4];`
	`739`	`+ dist[5] = (p_pre[j]+p_down[j])*2.5f - dist[4];`
	`740`	`+ dist[6] = (p_right[j]+p_right[j+1])*2.5f - dist[4];`
`737`	`741`
`738`	`742`
`739`	`743`	`dist[0] = dist[5] + p_right[j]*5 -p_Corner[j]-p_rd[j];`
`@@ -909,7 +913,7 @@ inline void DM::TV_two(float* __restrict p, float* __restrict p_right, float* __`
`909`	`913`	`inline void DM::DC_one(float* __restrict p, float* __restrict p_right, float* __restrict p_down, float * __restrict p_rd, float* __restrict p_pre, float* __restrict p_Corner)`
`910`	`914`	`{`
`911`	`915`	`register float dist[4];`
`912`		`- register float weight = -0.225603;`
	`916`	`+ register float weight = -0.225603f;`
`913`	`917`
`914`	`918`	`for (int j = 1; j < N_half; ++j)`
`915`	`919`	`{`
`@@ -933,7 +937,7 @@ inline void DM::DC_one(float* __restrict p, float* __restrict p_right, float* __`
`933`	`937`	`inline void DM::DC_two(float* __restrict p, float* __restrict p_right, float* __restrict p_down, float * __restrict p_rd, float* __restrict p_pre, float* __restrict p_Corner)`
`934`	`938`	`{`
`935`	`939`	`register float dist[4];`
`936`		`- register float weight = -0.225603;`
	`940`	`+ register float weight = -0.225603f;`
`937`	`941`
`938`	`942`	`for (int j = 0; j < N_half-1; ++j)`
`939`	`943`	`{`
`@@ -1001,16 +1005,16 @@ inline float DM::Scheme_MC(int i, float* p_pre, float* p, float* p_nex)`
`1001`	`1005`	`float dist[2];`
`1002`	`1006`	`float tmp = 8*p[i];`
`1003`	`1007`
`1004`		`- dist[0] = 2.5(p_pre[i]+p_nex[i]) + 5p[i+1] - p_pre[i+1] - p_nex[i+1] - tmp;`
`1005`		`- dist[1] = 2.5(p_pre[i]+p_nex[i]) + 5p[i-1] - p_pre[i-1] - p_nex[i-1] - tmp;`
	`1008`	`+ dist[0] = 2.5f(p_pre[i]+p_nex[i]) + 5p[i+1] - p_pre[i+1] - p_nex[i+1] - tmp;`
	`1009`	`+ dist[1] = 2.5f(p_pre[i]+p_nex[i]) + 5p[i-1] - p_pre[i-1] - p_nex[i-1] - tmp;`
`1006`	`1010`	`if(fabsf(dist[1])<fabsf(dist[0])) dist[0] = dist[1];`
`1007`	`1011`
`1008`		`- dist[1] = 2.5(p[i-1]+p[i+1]) + 5p_nex[i] - p_nex[i-1] - p_nex[i+1] - tmp;`
	`1012`	`+ dist[1] = 2.5f(p[i-1]+p[i+1]) + 5p_nex[i] - p_nex[i-1] - p_nex[i+1] - tmp;`
`1009`	`1013`	`if(fabsf(dist[1])<fabsf(dist[0])) dist[0] = dist[1];`
`1010`		`- dist[1] = 2.5(p[i-1]+p[i+1]) + 5p_pre[i]- p_pre[i-1] - p_pre[i+1] - tmp;`
	`1014`	`+ dist[1] = 2.5f(p[i-1]+p[i+1]) + 5p_pre[i]- p_pre[i-1] - p_pre[i+1] - tmp;`
`1011`	`1015`	`if(fabsf(dist[1])<fabsf(dist[0])) dist[0] = dist[1];`
`1012`	`1016`
`1013`		`- dist[0] /= 8.0;`
	`1017`	`+ dist[0] /= 8.0f;`
`1014`	`1018`
`1015`	`1019`	`return dist[0];`
`1016`	`1020`	`}`
`@@ -1095,7 +1099,7 @@ inline float DM::Scheme_TV(int i, float* p_pre, float* p, float* p_nex)`
`1095`	`1099`	`inline float DM::Scheme_DC(int i, float * __restrict p_pre, float * __restrict p, float * __restrict p_nex)`
`1096`	`1100`	`{`
`1097`	`1101`	`float dist[2];`
`1098`		`- float weight = -0.225603;`
	`1102`	`+ float weight = -0.225603f;`
`1099`	`1103`
`1100`	`1104`	`dist[0] = (p_pre[i] + p_nex[i])/2 + (p_pre[i+1] + p_nex[i+1] - 2p[i+1])weight - p[i];`
`1101`	`1105`	`dist[1] = (p_pre[i] + p_nex[i])/2 + (p_pre[i-1] + p_nex[i-1] - 2p[i-1])weight - p[i];`