cuikgradient.c

Go to the documentation of this file.

#include "box.h"
#include "random.h"
#include "defines.h"
#include "filename.h"
#include "cuiksystem.h"
#include "link.h"

#include <stdlib.h>

int main(int argc, char **arg)
{
  if (argc>1)
    {
      Tparameters parameters;
      TCuikSystem cuiksystem;

      Tfilename fcuik;
      Tfilename fparam;

      unsigned int i,n,k,m;
      double *sol;
      boolean state;
      boolean *systemVars;

      Tbox b_sol;
      unsigned int n_sol;

      unsigned int ri;
      
      /*Init parameters*/
      CreateFileName(NULL,arg[1],NULL,PARAM_EXT,&fparam);
      InitParametersFromFile(GetFileFullName(&fparam),&parameters);
      fprintf(stderr,"Reading parameter file            : %s\n",GetFileFullName(&fparam)); 

      /* Read the problem file */
      CreateFileName(NULL,arg[1],NULL,CUIK_EXT,&fcuik);
      InitCuikSystemFromFile(&parameters,GetFileFullName(&fcuik),&cuiksystem);
      fprintf(stderr,"Reading cuik file                 : %s\n",GetFileFullName(&fcuik));
      
      ri=(unsigned int)time(NULL);
      //ri=1405333052;
      randomSet(ri);
      fprintf(stderr,"Random seed                       : %u\n",ri);
      
      n=GetCSSystemVars(&systemVars,&cuiksystem);
      NEW(sol,n,double);

      if (argc>2)
        {
          unsigned int nErrors;

          m=atoi(arg[2]);
          n_sol=1;

          nErrors=0;
          for(k=0;k<m;k++)
            {
              state=CuikGradient(&parameters,sol,&b_sol,&cuiksystem);
              
              printf("Sample: %u\n",k+1);
              if (state)
                {
                  printf("   Solution %u\n",n_sol);
                  n_sol++;
                  printf("   Solution Point: ");
                  for(i=0;i<n;i++)
                    {
                      if (systemVars[i])
                        printf("%.16g ",sol[i]);
                    }
                  printf("\n   Solution Box  : ");
                  
                  PrintBoxSubset(stdout,systemVars,NULL,&b_sol);
                  printf("   Solution error: %g\n",ErrorInSolution(&b_sol,&cuiksystem));
                  printf("   Solution error: %g\n",ErrorInCSEquations(sol,&cuiksystem));
                }
              else
                {
                  printf("   Error in gradient\n");
                  nErrors++;
                }
              
              DeleteBox(&b_sol);
            } 
          printf("Gradient error ratio: %.2f\n",(double)nErrors/(double)m);
        }
      else
        {
          /* iterate over all boxes */ 
          Tfilename fsol,fgradient;
          FILE *fin;
          FILE *fout;
          Tbox box,b_sol;
          unsigned int out;
          int token;
          unsigned int nb;
          unsigned int rep;

          CreateFileName(NULL,arg[1],NULL,SOL_EXT,&fsol);
          rep=(unsigned int)(GetParameter(CT_REPRESENTATION,&parameters));
          if (rep==REP_JOINTS)
            CreateFileName(NULL,arg[1],"_gradient",JOINTS_EXT,&fgradient);
          else
            CreateFileName(NULL,arg[1],"_gradient",LINKS_EXT,&fgradient);

          fin=fopen(GetFileFullName(&fsol),"r");
          if (!fin)
            Error("Could not open the input file with the solutions");
          fprintf(stderr,"Reading solution file             : %s\n",GetFileFullName(&fsol));

          fout=fopen(GetFileFullName(&fgradient),"w");
          fprintf(stderr,"Writing samples to                : %s\n",GetFileFullName(&fgradient));

          nb=0;
          do {
            token=ReadBox(fin,&box);
            if (token!=EOF)
              { 
                out=CuikGradientInBox(&parameters,&box,sol,&b_sol,&cuiksystem);
                nb++;
                
                switch(out)
                  {
                  case DIVERGED:
                    fprintf(fout,"*DV \n");
                    break;
                  case CONVERGED_OUTSIDE_GLOBAL:
                    /* Use the center of the box */
                    fprintf(fout,"*CO(%g) \n   ",ErrorInSolution(&b_sol,&cuiksystem));
                    break;
                  case CONVERGED_IN_GLOBAL:
                    fprintf(fout,"*CG(%g) \n   ",ErrorInSolution(&b_sol,&cuiksystem));
                    break;
                  case CONVERGED_IN_BOX:
                    fprintf(fout,"*CV(%g) \n   ",ErrorInSolution(&b_sol,&cuiksystem));
                    break;
                  default:
                    Error("Unknown output from CuikGradientInBox");
                  }

                for(i=0;i<n;i++)
                  {
                    if (systemVars[i])
                      fprintf(fout,"%.12g ",sol[i]);
                  }
                fprintf(fout,"\n");

                DeleteBox(&box);
                DeleteBox(&b_sol);
              }
          } while (token!=EOF);
          
          fclose(fin);
          fclose(fout);
          DeleteFileName(&fsol);
          DeleteFileName(&fgradient);
        }

      free(systemVars);
      free(sol);

      DeleteCuikSystem(&cuiksystem);
      DeleteParameters(&parameters);

      DeleteFileName(&fcuik);
      DeleteFileName(&fparam);
    }
  else
    { 
      fprintf(stderr,"  Wrong number of parameters.\n");
      fprintf(stderr,"  Use:\n");   
      fprintf(stderr,"      cuikgradient <problem filename>.cuik <n>\n");
      fprintf(stderr,"      cuikgradient <problem filename>.cuik \n");
      fprintf(stderr,"  where\n"); 
      fprintf(stderr,"    <n> is the number of gradient descents to execute\n");
      fprintf(stderr,"    <problem filename> contains the kinematic equations\n");
      fprintf(stderr,"              (the '.cuik' extension is not required)\n");
      fprintf(stderr,"  In the first case, we attempt to generate <n> random samples.\n");
      fprintf(stderr,"  In the second case, we generte one sample for each one of\n");
      fprintf(stderr,"  the solution boxes in the  <problem filename>.sol file.\n");
    }

  return(EXIT_SUCCESS);
}