コード例 #1
0
ファイル: gpunewton_qd.cpp プロジェクト: callmetaste/PHCpack
int newton ( int mode, int verbose, PolySys& p, PolySolSet& s )
{
   double teval,tmgs;
   bool success;
   CT* sol = s.get_sol(0);
   CT alpha;
   CT *x_gpu;
   CPUInstHom cpu_inst_hom;
   Workspace workspace_cpu;
   Parameter path_parameter(N_PREDICTOR, MAX_STEP, MAX_IT, MAX_DELTA_T, \
      MAX_DELTA_T_END, MIN_DELTA_T, ERR_MAX_RES, ERR_MAX_DELTA_X, \
      ERR_MAX_FIRST_DELTA_X, ERR_MIN_ROUND_OFF, MAX_IT_REFINE, \
      ERR_MIN_ROUND_OFF_REFINE, STEP_INCREASE, STEP_DECREASE);

   if(verbose > 0)
   {
      cout << "The first solution on input :" << endl;
      for(int k=0; k<p.dim; k++)
      {
         cout << k << " :";
         cout << setw(72) << scientific << setprecision(64) << sol[k];
      }
   }
   alpha = CT(1,0);
   cpu_inst_hom.init(p,p,p.dim,p.n_eq,1,alpha,verbose);
   cpu_inst_hom.init_workspace(workspace_cpu);

   if(mode == 0 || mode == 1)
   {
      workspace_cpu.init_x_t_idx();
      workspace_cpu.update_x_t_value(sol,alpha);
      success = CPU_Newton
                   (workspace_cpu,cpu_inst_hom,path_parameter,teval,tmgs);
      if(verbose > 0)
      {
         cout.precision(64);
         cout << "The first solution after CPU_Newton :" << endl;
         for(int k=0; k<p.dim; k++)
            cout << k << " :" << setw(72) << workspace_cpu.x[k];
      }
   }
   if(mode == 0 || mode == 2)
   {
      alpha = CT(1,0);
      success = GPU_Newton(cpu_inst_hom,path_parameter,sol,alpha,x_gpu,
                           1,verbose);
      if(verbose > 0)
      {
         cout << "The first solution after GPU_Newton :" << endl;
         for(int k=0; k<p.dim; k++)
         cout << k << " :" << setw(72) << x_gpu[k];
      }
   }
   if(mode == 1)
      s.change_sol(0,workspace_cpu.x);
   else
      s.change_sol(0,x_gpu);

   return 0;
}
コード例 #2
0
ファイル: ada_test_dd.cpp プロジェクト: callmetaste/PHCpack
void ada_write_sols ( PolySolSet& sols )
{
   int fail = solcon_clear_dobldobl_solutions();
   if(fail != 0)
      std::cout << "failed to clear the solutions" << std::endl;
   int dim = sols.dim;
   int nbsols = sols.n_sol;

   for(int sol_idx=0; sol_idx<nbsols; sol_idx++)
   {
      CT* sol = sols.get_sol(sol_idx);
      double csol[4*dim+10];
      csol[0] = 0.0; csol[1] = 0.0;
      csol[2] = 0.0; csol[3] = 0.0;
      int idx = 4;
      for(int k=0; k<dim; k++)
      {
         csol[idx++] = sol[k].real.x[0];
         csol[idx++] = sol[k].real.x[1];
         csol[idx++] = sol[k].imag.x[0];
         csol[idx++] = sol[k].imag.x[1];
      }
      csol[4*dim+4] = 0.0; csol[4*dim+5] = 0.0;
      csol[4*dim+6] = 0.0; csol[4*dim+7] = 0.0;
      csol[4*dim+8] = 0.0; csol[4*dim+9] = 0.0;
      fail = solcon_append_dobldobl_solution(dim,1,csol);
      if(fail != 0)
         std::cout << "failed to append the solution" << std::endl;
   }
}
コード例 #3
0
ファイル: ada_test_dd.cpp プロジェクト: callmetaste/PHCpack
void ada_read_sols ( PolySys& start_sys, PolySolSet& sols )
{
   int fail, len;

   fail = solcon_number_of_dobldobl_solutions(&len);
   // printf("Number of start solutions : %d\n",len);
   int dim=start_sys.dim;
   sols.dim = dim;
   double sol[4*dim+10];

   for(int sol_idx=1; sol_idx<len+1; sol_idx++)
   {
      int mm,k,pos;
      T1 dd_sol[2*dim];
      T1 t_real,t_imag,err,rco,res;

      solcon_retrieve_next_dobldobl_solution(dim,&k,&mm,sol);
      //solcon_retrieve_solution(dim,sol_idx,&mm,sol);
      /*std::cout << sol[0] << " " << sol[1] << std::endl;
      for(int var_idx=0; var_idx<4; var_idx++)
         std::cout << sol[2+2*var_idx] << " " << sol[2+2*var_idx] << std::endl;
      std::cout << sol[2+2*dim] 
                << " " << sol[3+2*dim]
                << " " << sol[4+2*dim] << std::endl;*/
      t_real.x[0] = sol[0];
      t_real.x[1] = sol[1];
      t_imag.x[0] = sol[2];
      t_imag.x[1] = sol[3];
      pos = 4;
      for(int dd_sol_idx=0; dd_sol_idx<2*dim; dd_sol_idx++)
      {
         T1 sol_real,sol_imag;
         sol_real.x[0] = sol[pos++];
         sol_real.x[1] = sol[pos++];
         sol_imag.x[0] = sol[pos++];
         sol_imag.x[1] = sol[pos++];
         dd_sol[dd_sol_idx++] = sol_real;
         dd_sol[dd_sol_idx] = sol_imag;
      }
      err.x[0] = sol[4*dim+4];
      err.x[1] = sol[4*dim+5];
      rco.x[0] = sol[4*dim+6];
      rco.x[1] = sol[4*dim+7];
      res.x[0] = sol[4*dim+8];
      res.x[1] = sol[4*dim+9];
      PolySol* tmp_sol = new PolySol(dim,t_real,t_imag,dd_sol,err,rco,res);
      //tmp_sol->print_info(start_sys.pos_var);
      sols.add_sol(tmp_sol);
   }

   // std::cout << "sol finished" << std::endl;
}
コード例 #4
0
ファイル: ada_test_qd.cpp プロジェクト: janverschelde/PHCpack
void ada_read_sols ( PolySys& start_sys, PolySolSet& sols )
{
    int fail, len;

    fail = solcon_number_of_quaddobl_solutions(&len);
    // printf("Number of start solutions : %d\n",len);
    int dim=start_sys.dim;
    sols.dim = dim;
    double sol[8*dim+20];

    for(int sol_idx=1; sol_idx<len+1; sol_idx++)
    {
        int mm,k,pos;
        // T1 qd_sol[4*dim];
        T1* qd_sol;
        T1 t_real,t_imag,err,rco,res;

        qd_sol = (T1*)calloc(4*dim,sizeof(T1));

        solcon_retrieve_next_quaddobl_solution(dim,&k,&mm,sol);
        //solcon_retrieve_solution(dim,sol_idx,&mm,sol);
        /*std::cout << sol[0] << " " << sol[1] << std::endl;
        for(int var_idx=0; var_idx<4; var_idx++)
           std::cout << sol[2+2*var_idx] << " " << sol[2+2*var_idx] << std::endl;
        std::cout << sol[2+2*dim]
                  << " " << sol[3+2*dim]
                  << " " << sol[4+2*dim] << std::endl;*/
        t_real.x[0] = sol[0];
        t_real.x[1] = sol[1];
        t_real.x[2] = sol[2];
        t_real.x[3] = sol[3];
        t_imag.x[0] = sol[4];
        t_imag.x[1] = sol[5];
        t_imag.x[2] = sol[6];
        t_imag.x[3] = sol[7];
        pos = 8;
        for(int qd_sol_idx=0; qd_sol_idx<4*dim; qd_sol_idx++)
        {
            T1 sol_real,sol_imag;
            sol_real.x[0] = sol[pos++];
            sol_real.x[1] = sol[pos++];
            sol_real.x[2] = sol[pos++];
            sol_real.x[3] = sol[pos++];
            sol_imag.x[0] = sol[pos++];
            sol_imag.x[1] = sol[pos++];
            sol_imag.x[2] = sol[pos++];
            sol_imag.x[3] = sol[pos++];
            qd_sol[qd_sol_idx++] = sol_real;
            qd_sol[qd_sol_idx] = sol_imag;
        }
        err.x[0] = sol[8*dim+8];
        err.x[1] = sol[8*dim+9];
        err.x[2] = sol[8*dim+10];
        err.x[3] = sol[8*dim+11];
        rco.x[0] = sol[8*dim+12];
        rco.x[1] = sol[8*dim+13];
        rco.x[2] = sol[8*dim+14];
        rco.x[3] = sol[8*dim+15];
        res.x[0] = sol[8*dim+16];
        res.x[1] = sol[8*dim+17];
        res.x[2] = sol[8*dim+18];
        res.x[3] = sol[8*dim+19];
        PolySol* tmp_sol = new PolySol(dim,t_real,t_imag,qd_sol,err,rco,res);
        // tmp_sol->print_info(start_sys.pos_var);
        sols.add_sol(tmp_sol);
    }
    // sols.print_info(start_sys.pos_var);
    // std::cout << "sol finished" << std::endl;
}
コード例 #5
0
int manytrack
 ( int mode, int verbose, double regamma, double imgamma,
   PolySys& p, PolySys& q, PolySolSet& s )
{
   double tpred,teval,tmgs;
   bool success;
   CT* sol = s.get_sol(0);
   CT alpha,t;
   CT *x_gpu;
   CPUInstHom cpu_inst_hom;
   Workspace workspace_cpu;
   Parameter path_parameter(N_PREDICTOR, MAX_STEP, MAX_IT, MAX_DELTA_T, \
      MAX_DELTA_T_END, MIN_DELTA_T, ERR_MAX_RES, ERR_MAX_DELTA_X, \
      ERR_MAX_FIRST_DELTA_X, ERR_MIN_ROUND_OFF, MAX_IT_REFINE, \
      ERR_MIN_ROUND_OFF_REFINE, STEP_INCREASE, STEP_DECREASE);
  
   if(verbose > 0)
   {
      cout << "The first solution on input :" << endl;
      for(int k=0; k<p.dim; k++)
      {
         cout << k << " :";
         cout << setw(40) << scientific << setprecision(32) << sol[k];
      }
   }
   int fail,n_path;
   fail = solcon_number_of_dobldobl_solutions(&n_path);

   alpha = CT(regamma,imgamma);
   cpu_inst_hom.init(p,q,p.dim,p.n_eq,1,alpha,verbose);
   cpu_inst_hom.init_workspace(workspace_cpu);

   if(mode == 0 || mode == 1)
   {
      for(int path_idx=0; path_idx<n_path; path_idx++)
      {
         if(verbose > 0) cout << "tracking path " << path_idx << endl;
         CT* sol0 = s.get_sol(path_idx);
         CT* sol_new = NULL;
         t = CT(0.0,0);
         workspace_cpu.init_x_t_idx();
         workspace_cpu.update_x_t_value(sol0,t);
         workspace_cpu.update_x_t_idx();
         workspace_cpu.path_idx = path_idx;
         tpred = 0.0; teval = 0.0; tmgs = 0.0;
         if(verbose > 0) cout << "calling path_tracker ..." << endl;
         success = path_tracker(workspace_cpu,cpu_inst_hom,path_parameter,
                                tpred,teval,tmgs,0,verbose);
         if(verbose > 0) cout << "done with call to path_tracker." << endl;
         if(mode == 1) s.change_sol(path_idx,workspace_cpu.x_last);
         if(verbose > 0)
         {
            cout.precision(32);
            cout << "The solution " << path_idx << endl;
            for(int k=0; k<p.dim; k++)
               cout << k << " :" << setw(40) << workspace_cpu.x_last[k];
         }
      }
   }
   if(mode == 0 || mode == 2)
   {
      CT* sol0 = new CT[n_path*cpu_inst_hom.dim];
      CT* sol_tmp_mult = sol0;
      CT* tt = new CT[n_path];
      CT** x_gpu = NULL;
      for(int path_idx=0; path_idx<n_path; path_idx++)
      {
         CT* sol_tmp = s.get_sol(path_idx);
         for(int sol_idx=0; sol_idx<cpu_inst_hom.dim; sol_idx++)
         {
            *sol_tmp_mult++ = sol_tmp[sol_idx];
         }
         tt[path_idx] = CT(0.0,0.0);
      }
      success = GPU_Path_mult
         (cpu_inst_hom,path_parameter,sol0,tt,x_gpu,n_path,verbose);
      for(int path_idx=0; path_idx<n_path; path_idx++)
      {
         s.change_sol(path_idx,x_gpu[path_idx]);
      }
      if(verbose > 0)
      {
         cout << "The first solution after GPU path tracker :" << endl;
         cout.precision(32);
         for(int k=0; k<p.dim; k++)
            cout << k << " :" << setw(40) << x_gpu[0][k];
      }
      delete[] tt;
   }
   return 0;
}