Ejemplo n.º 1
0
 void NEHCalc::NEH()
 {
	 int NumberofAddedTasks = 0, Tempi = 0, TempCmax = 0;
	 for (std::vector<SingleTask*>::iterator itr = ListofSortedTasks.begin(); itr!= (ListofSortedTasks.end() -1); itr++)
	 {
		 if (((*itr)->GetLength() == (*(itr+1))->GetLength()) && ((*itr)->GetNumberofTask() > (*(itr+1))->GetNumberofTask()))
		 {
			 std::swap(*(itr), *(itr + 1));
		 }
	 }
	 std::vector<SingleTask*>::iterator itr = ListofSortedTasks.begin();

	 UpdateR(*(ListofSortedTasks.begin()), 0, NumberofAddedTasks);
	 UpdateQ(*(ListofSortedTasks.begin()), 0, NumberofAddedTasks++);
	 ListofOrderedTasks.push_back(*(itr));
	 ListofSortedTasks.erase(itr);
	 while (!ListofSortedTasks.empty())
	 {
		 TempCmax = CountCmax((*(ListofSortedTasks.begin())), 0, NumberofAddedTasks);
		 Tempi = 0;
		 for (int i = 1; i <= NumberofAddedTasks; i++)
		 {
			//std::cout << TempCmax <<" " << CountCmax((*(ListofSortedTasks.begin())),i,NumberofAddedTasks) << std::endl;
			//if ((*ListofSortedTasks.begin())->GetNumberofTask() == 20)
			 //{
			//	 std::cout << TempCmax << " " << CountCmax((*(ListofSortedTasks.begin())), i, NumberofAddedTasks)<<std::endl;
			 //}

			if (TempCmax > CountCmax((*(ListofSortedTasks.begin())), i, NumberofAddedTasks))
			{
				TempCmax = CountCmax((*(ListofSortedTasks.begin())), i, NumberofAddedTasks);
				Tempi = i;
			}
		 }
		 //std::cout << Tempi;
		 UpdateR(*(ListofSortedTasks.begin()), Tempi, NumberofAddedTasks);
		 UpdateQ(*(ListofSortedTasks.begin()), Tempi, NumberofAddedTasks);
		 //ShowRData();
		 //std::cout << std::endl;
		 //ShowQData();
		 //std::cout << std::endl;
		 ListofOrderedTasks.insert(ListofOrderedTasks.begin() + Tempi, *(ListofSortedTasks.begin()));
		 ListofSortedTasks.erase(ListofSortedTasks.begin());
		 /*for (std::vector<SingleTask*>::iterator itr = ListofOrderedTasks.begin(); itr!= ListofOrderedTasks.end(); itr++)
		 {
			 std::cout << (*itr)->GetNumberofTask() << " ";
		 }
		 std::cout << std::endl;*/
		 NumberofAddedTasks++;
	 }
	 std::cout << "Cmax is: " << TableofR[_NumberofMachines-1][_NumberofTasks-1] << std::endl;
	 //UpdateR((*(ListofSortedTasks.begin()+1)), 0,  0);
	 //UpdateQ((*(ListofSortedTasks.begin()+1)), 0,  0);
	 //ListofOrderedTasks.push_back((*(ListofSortedTasks.begin()+1)));
	 
	 //UpdateR((*(ListofSortedTasks.begin()+3)), 1,  1);
	 //UpdateQ((*(ListofSortedTasks.begin()+3)), 1,  1);
	 //ListofOrderedTasks.push_back((*(ListofSortedTasks.begin()+3)));
	 //std:: cout << CountCmax((*(ListofSortedTasks.begin())), 2, 2) << std::endl;
	 //UpdateR((*(ListofSortedTasks.begin())), 0,  1);
	 /*UpdateQ((*(ListofSortedTasks.begin())), 0,  1);
	 ListofOrderedTasks.push_back((*(ListofSortedTasks.begin())));
	 std::swap(*(ListofOrderedTasks.begin()),*(ListofOrderedTasks.begin()+1));
	 UpdateR((*(ListofSortedTasks.begin()+1)), 1,  2);
	 UpdateQ((*(ListofSortedTasks.begin()+1)), 1,  2);
	 ListofOrderedTasks.push_back((*(ListofSortedTasks.begin())));*/
	 //UpdateQ((*(ListofSortedTasks.begin()+3)), 1,  1);
	 //UpdateR((*(ListofSortedTasks.begin()+3)), 1, 1 );
	 //ListofOrderedTasks.push_back((*(ListofSortedTasks.begin()+3)));
	 //UpdateR((*(ListofSortedTasks.begin()+2)), 1, 2 );*/
	 
	 //ListofOrderedTasks.push_back((*(ListofSortedTasks.begin()+2)));
	 //std::swap(*(ListofOrderedTasks.begin()+1),*(ListofOrderedTasks.begin()+2));
	 //UpdateR((*(ListofSortedTasks.begin()+1)), 1, 3 );
	 //UpdateR((*(ListofSortedTasks.begin()+2)), 2 );
	 //UpdateR((*(ListofSortedTasks.begin()+3)), 3 );
	 //ListofOrderedTasks.push_back((*ListofSortedTasks.begin()));
	 //ListofSortedTasks.pop_front();


 }
Ejemplo n.º 2
0
int FAMGSystem::Arnoldi(FAMGMultiGrid *mg0, double **vec, double *H, double *G, double *Q, double *P, double &q0, int con)
{
	assert(0); // to port
#ifdef FAMG_GMRES
	double q, gamma, oldgamma, h[famgnv], c, s, nenner;
     int i,j,nv;
     ostrstream ostr;
           
     nv = famgparaptr->Getnv();  
     for(i = 0; i < (nv+1)*(nv+1); i++) Q[i] = 0.0;

     q = FAMGNorm(n,vector[FAMGDEFECT]);
     FAMGCopyScaledVector(n,vec[0],vector[FAMGDEFECT],1.0/q); 
     q0 = q;
     Q[0] = 1.0;
     oldgamma = q0;

     // Arnoldi process
     for(i = 0; i < nv; i++)
     {
         // def = M^{-1}A v_{i-1}
         FAMGCopyScaledVector(n,vec[i],vector[FAMGDEFECT],1.0/q); 
         FAMGCopyVector(n,vector[FAMGRHS],vec[i]);
         FAMGSetVector(n,vector[FAMGUNKNOWN],0.0);
         FAMGCopyVector(n,vector[FAMGDEFECT],vector[FAMGRHS]);
         if(con)
         {
             if(mg0->Step(0))
			 {
			 	mg0->Deconstruct();
			 	RETURN(1);
			 }
         }
         else
         {
             mg0->SGSStep(0);
         }
         FAMGSetSubVector(n,vector[FAMGDEFECT],vector[FAMGRHS],vector[FAMGDEFECT]);
 
         // modified Gram-Schmitt
         for(j = 0; j <= i; j++)
         {
             h[j] = FAMGScalProd(n,vector[FAMGDEFECT],vec[j]);
             FAMGAddVector(n,vector[FAMGDEFECT],vec[j],-h[j]);
         }

         q = FAMGNorm(n,vector[FAMGDEFECT]);
         if(q < 1e-10) 
         {
             ostr << __FILE__ << ", line " << __LINE__ << ": GMRES breakdownl" << endl;
             FAMGWarning(ostr);
         }
         // => def = v_i*q

         // update H
         FAMGMatVecMult(i+1,nv+1,Q,h);
         UpdateH(i,nv,H,h);

         if(i == nv-1)
         {
             for(j = 0; j < (nv*nv); j++) G[j] = H[j];
             for(j = 0; j < ((nv+1)*(nv+1)); j++) P[j] = Q[j];
         }
           

         // eliminate H_{i+1,i} = q
         nenner = sqrt(h[i]*h[i] + q*q);
         c = h[i]/nenner; s = q/nenner;
         UpdateQ(i,nv+1,Q,c,s);
        
         // only H_{i,i} must be modified at this point
         H[nv*i+i] = nenner;

         // check convergence
         gamma = Abs(q0*Q[(nv+1)*(i+1)]);
         ostr << i+1 << "\t" << gamma << "\t" << gamma/oldgamma << endl;
         FAMGWrite(ostr);
         oldgamma = gamma;

     }
#endif

     return 0;
}