コード例 #1
0
ファイル: RelayProblem.c プロジェクト: bremond/siconos
int relay_newFromFile(RelayProblem* problem, FILE* file)
{
  int n = 0;
  int i;

  CHECK_IO(fscanf(file, "%d\n", &n));
  problem->size = n;
  problem->M = newNumericsMatrix();

  newFromFile(problem->M, file);

  problem->q = (double *) malloc(problem->M->size1 * sizeof(double));
  for (i = 0; i < problem->M->size1; i++)
  {
    CHECK_IO(fscanf(file, "%lf ", &(problem->q[i])));
  }

  problem->lb = (double *) malloc(problem->M->size1 * sizeof(double));
  for (i = 0; i < problem->M->size1; i++)
  {
    CHECK_IO(fscanf(file, "%lf ", &(problem->lb[i])));
  }

  problem->ub = (double *) malloc(problem->M->size1 * sizeof(double));
  for (i = 0; i < problem->M->size1; i++)
  {
    CHECK_IO(fscanf(file, "%lf ", &(problem->ub[i])));
  }
  return 1;
}
コード例 #2
0
ファイル: NumericsMatrix.c プロジェクト: fperignon/siconos
void readInFile(NumericsMatrix* const m, FILE *file)
{
    if (! m)
    {
        fprintf(stderr, "Numerics, NumericsMatrix readInFile failed, NULL input.\n");
        exit(EXIT_FAILURE);
    }
    CHECK_IO(fscanf(file, "%d", &(m->storageType)));
    CHECK_IO(fscanf(file, "%d", &(m->size0)));
    CHECK_IO(fscanf(file, "%d", &(m->size1)));
    int storageType = m->storageType;

    if (storageType == 0)
    {
        CHECK_IO(fscanf(file, "%d\t%d\n", &(m->size0), &(m->size1)));

        for (int i = 0; i < m->size1 * m->size0; i++)
        {
            CHECK_IO(fscanf(file, "%le ", &(m->matrix0[i])));
        }


    }
    else if (storageType == 1)
    {
        m->matrix0 = NULL;
        readInFileSBM(m->matrix1, file);
    }
}
コード例 #3
0
ファイル: globals.c プロジェクト: Lance0312/tcsh
int is_gui(char *exename) {

        HANDLE hImage;

        DWORD  bytes;
        OVERLAPPED overlap;

        ULONG  ntSignature;

        struct DosHeader{
                IMAGE_DOS_HEADER     doshdr;
                DWORD                extra[16];
        };

        struct DosHeader dh;
        IMAGE_OPTIONAL_HEADER optionalhdr;

        int retCode = 0;

        memset(&overlap,0,sizeof(overlap));


        hImage = CreateFile(exename, GENERIC_READ, FILE_SHARE_READ, NULL,
                        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL| FILE_FLAG_OVERLAPPED, NULL);
        if (INVALID_HANDLE_VALUE == hImage) {
                return 0;
        }

        ReadFile(hImage, &dh, sizeof(struct DosHeader), &bytes,&overlap);
        CHECK_IO(hImage,&overlap);


        if (IMAGE_DOS_SIGNATURE != dh.doshdr.e_magic) {
                goto done;
        }

        // read from the coffheaderoffset;
        overlap.Offset = dh.doshdr.e_lfanew;

        ReadFile(hImage, &ntSignature, sizeof(ULONG), &bytes,&overlap);
        CHECK_IO(hImage,&overlap);

        if (IMAGE_NT_SIGNATURE != ntSignature) {
                goto done;
        }
        overlap.Offset = dh.doshdr.e_lfanew + sizeof(ULONG) +
                sizeof(IMAGE_FILE_HEADER);

        ReadFile(hImage, &optionalhdr,IMAGE_SIZEOF_NT_OPTIONAL_HEADER, &bytes,&overlap);
        CHECK_IO(hImage,&overlap);

        if (optionalhdr.Subsystem ==IMAGE_SUBSYSTEM_WINDOWS_GUI)
                retCode =  1;
done:
        CloseHandle(hImage);
        return retCode;
}
コード例 #4
0
ファイル: proj3io.c プロジェクト: zcsevcik/edu
bool vm_load(VectorOfMatrices* vm, const char* filename)
{
    assert(vm != NULL);

    FILE* fp = fopen(filename, "r");
    if (fp == NULL) {
        perror(filename);
        goto return_false;
    }

    int fmt;
    unsigned long count;
    unsigned long rows;
    unsigned long cols;

    int suc = fscanf(fp, "%d", &fmt);
    CHECK_IO(suc, 1, return_false);
    if (fmt != FMT_VECTOR_OF_MATRICES) {
        goto return_false;
    }

    suc = fscanf(fp, "%lu %lu %lu", &count, &rows, &cols);
    CHECK_IO(suc, 3, return_false);
    if (rows <= 0 || cols <= 0 || count <= 0) {
        goto return_false;
    }
    vm->rows = rows;
    vm->cols = cols;
    vm->count = count;
    if (!vm_alloc(vm)) {
        goto return_false;
    }

    int* pvm = vm->items;
    size_t iter_count = rows * cols * count;
    for (size_t i = 0; i < iter_count; ++i) {
        suc = fscanf(fp, "%d", pvm++);
        CHECK_IO(suc, 1, return_false);
    }

    if (fclose(fp) != 0) {
        perror(filename);
    }

    return true;

return_false:
    if (fp != NULL && fclose(fp) != 0) {
        perror(filename);
    }

    vm_free(vm);
    return false;
}
コード例 #5
0
ファイル: proj3io.c プロジェクト: zcsevcik/edu
bool matrix_load(Matrix* mat, const char* filename)
{
    assert(mat != NULL);

    FILE* fp = fopen(filename, "r");
    if (fp == NULL) {
        perror(filename);
        goto return_false;
    }

    int fmt;
    unsigned long rows;
    unsigned long cols;

    int suc = fscanf(fp, "%d", &fmt);
    CHECK_IO(suc, 1, return_false);
    if (fmt != FMT_MATRIX) {
        goto return_false;
    }

    suc = fscanf(fp, "%lu %lu", &rows, &cols);
    CHECK_IO(suc, 2, return_false);
    if (rows <= 0 || cols <= 0) {
        goto return_false;
    }
    mat->rows = rows;
    mat->cols = cols;
    if (!matrix_alloc(mat)) {
        goto return_false;
    }

    int* pMat = mat->items;
    size_t count = rows * cols;
    for (size_t i = 0; i < count; ++i) {
        suc = fscanf(fp, "%d", pMat++);
        CHECK_IO(suc, 1, return_false);
    }

    if (fclose(fp) != 0) {
        perror(filename);
    }

    return true;

return_false:
    if (fp != NULL && fclose(fp) != 0) {
        perror(filename);
    }

    matrix_free(mat);
    return false;
}
コード例 #6
0
int linearComplementarity_newFromFile(LinearComplementarityProblem* problem, FILE* file)
{
  int n = 0;
  int i;

  CHECK_IO(fscanf(file, "%d\n", &n));
  problem->size = n;
  problem->M = NM_new_from_file(file);

  problem->q = (double *) malloc(problem->M->size1 * sizeof(double));
  for (i = 0; i < problem->M->size1; i++)
  {
    CHECK_IO(fscanf(file, "%lf ", &(problem->q[i])));
  }
  return 1;
}
コード例 #7
0
ファイル: NumericsMatrix.c プロジェクト: fperignon/siconos
int newFromFile(NumericsMatrix* const m, FILE *file)
{
    if (! m)
    {
        fprintf(stderr, "Numerics, NumericsMatrix newFromFile failed, NULL input.\n");
        exit(EXIT_FAILURE);
    }

    int storageType;
    size_t size0;
    size_t size1;
    int info = 0;
    void* data = NULL;

    CHECK_IO(fscanf(file, "%d", &storageType), &info);
    CHECK_IO(fscanf(file, SN_SIZE_T_F, &size0), &info);
    CHECK_IO(fscanf(file, SN_SIZE_T_F, &size1), &info);

    if (storageType == NM_DENSE)
    {
        CHECK_IO(fscanf(file, SN_SIZE_T_F "\t" SN_SIZE_T_F "\n", &size0, &size1), &info);

        data = malloc(size1 * size0 * sizeof(double));
        double* data_d = (double*) data;

        for (size_t i = 0; i < size1 * size0; ++i)
        {
            CHECK_IO(fscanf(file, "%le ", &(data_d[i])), &info);
        }
    }
    else if (storageType == NM_SPARSE_BLOCK)
    {
        data = newSBM();
        newFromFileSBM((SparseBlockStructuredMatrix*)data, file);
    }

    fillNumericsMatrix(m, storageType, (int)size0, (int)size1, data);

    return info;
}
コード例 #8
0
int globalFrictionContact_newFromFile(GlobalFrictionContactProblem* problem, FILE* file)
{
  int nc = 0, d = 0;
  int info = 0;
  CHECK_IO(fscanf(file, "%d\n", &d), &info);
  problem->dimension = d;
  CHECK_IO(fscanf(file, "%d\n", &nc), &info);
  problem->numberOfContacts = nc;
  problem->M = newNumericsMatrix();

  info = newFromFile(problem->M, file);
  if (info) goto fail;

  problem->H = newNumericsMatrix();
  info = newFromFile(problem->H, file);
  if (info) goto fail;

  problem->q = (double *) malloc(problem->M->size1 * sizeof(double));
  for (int i = 0; i < problem->M->size1; ++i)
  {
    CHECK_IO(fscanf(file, "%lf ", &(problem->q[i])), &info);
  }
  problem->b = (double *) malloc(problem->H->size1 * sizeof(double));
  for (int i = 0; i < problem->H->size1; ++i)
  {
    CHECK_IO(fscanf(file, "%lf ", &(problem->b[i])), &info);
  }

  problem->mu = (double *) malloc(nc * sizeof(double));
  for (int i = 0; i < nc; ++i)
  {
    CHECK_IO(fscanf(file, "%lf ", &(problem->mu[i])), &info);
  }

fail:
  problem->env = NULL;
  problem->workspace = NULL;
  return info;
}
コード例 #9
0
int secondOrderConeLinearComplementarityProblem_newFromFile(SecondOrderConeLinearComplementarityProblem* problem, FILE* file)
{
  DEBUG_PRINT("Start -- int secondOrderConeLinearComplementarityProblem_newFromFile(SecondOrderConeLinearComplementarityProblem* problem, FILE* file)\n");
  int n = 0;
  int nc = 0;
  int i;

  CHECK_IO(fscanf(file, "%d\n", &n));
  problem->n = n;
  CHECK_IO(fscanf(file, "%d\n", &nc));
  problem->nc = nc;
  problem->M = newNumericsMatrix();

  /* fix: problem->M->storageType unitialized ! */

  newFromFile(problem->M, file);

  problem->q = (double *) malloc(problem->M->size1 * sizeof(double));
  for(i = 0; i < problem->M->size1; i++)
  {
    CHECK_IO(fscanf(file, "%lf ", &(problem->q[i])));
  }
  problem->coneIndex = (unsigned int *) malloc((nc+1) * sizeof(unsigned int));
  for(i = 0; i < nc+1; i++)
  {
    CHECK_IO(fscanf(file, "%d ", &(problem->coneIndex[i])));
  }

  problem->mu = (double *) malloc(nc * sizeof(double));
  for(i = 0; i < nc; i++)
  {
    CHECK_IO(fscanf(file, "%lf ", &(problem->mu[i])));
  }
  DEBUG_PRINT("End --  int secondOrderConeLinearComplementarityProblem_newFromFile(SecondOrderConeLinearComplementarityProblem* problem, FILE* file)\n");

  return 0;
}
コード例 #10
0
ファイル: SolverOptions.c プロジェクト: xhub/siconos
void readSolverOptions(int driverType, SolverOptions* options)
{
  /* To each problem, corresponds a XXX_parameters.opt file where default parameters can be read, XXX being the problem name (LCP, FrictionContact3D ...) */

  if (verbose > 0)
    printf("\n ========== Numerics Non Smooth Solver - Read default parameters for the solver.\n ==========");

  // Checks if NUMERICSSPATH is set.
  if (getenv("SICONOSPATH") == NULL)
  {
    fprintf(stderr, "Numerics, readSolverOptions error, SICONOSPATH environment variable not set. Can not find default solver options file.\n");
    return;
    //exit(EXIT_FAILURE);
  }

  FILE * ficin;
  /* Name of the default parameters file */
  char name[MAX_ENV_SIZE];
  char nameSuffix[] = "/include/siconos";

  strncpy(name, getenv("SICONOSPATH"), MAX_ENV_SIZE - sizeof(nameSuffix));
  strcat(name, nameSuffix);

  char buffer[64];
  char bufferName[64];
  /* Return value for reading */
  int nval;

  // set default size to 4 ...
  if (options->iparam == NULL)
    options->iparam = (int*)malloc(4 * sizeof(*options->iparam));
  if (options->dparam == NULL)
    options->dparam = (double*)malloc(4 * sizeof(*options->dparam));

  switch (driverType)
  {

  case 0:
    strcat(name, "LCP_parameters.opt");
    break;
  case 1:
    strcat(name, "dfc2D_parameters.opt");
    break;
  case 2:
    strcat(name, "FrictionContact2D_parameters.opt");
    break;
  case 3:
    strcat(name, "FrictionContact3D_parameters.opt");
    ficin = fopen(name, "r");
    if (verbose > 0)
      printf("The default-parameters file is: %s\n", name);
    if (!ficin)
    {
      printf("Numerics, readSolverOptions error. Can not open file %60s", name);
      exit(-1);
    }
    //nval = fscanf(ficin, "%c", &(options->solverName));
    CHECK_IO(fgets(buffer, 64, ficin));
    CHECK_IO(fgets(buffer, 64, ficin));
    CHECK_IO(fgets(buffer, 64, ficin));
    /* Solver name */
    CHECK_IO(fgets(bufferName , 64, ficin));
    options->solverId = nameToId(bufferName);
    CHECK_IO(fgets(buffer, 64, ficin));
    /* iparam */
    nval = fscanf(ficin, "%d%d", &(options->iparam[0]), &(options->iparam[1]));
    if (nval != 4)
    {
      fprintf(stderr, "Numerics, readSolverOptions error, wrong number of parameters for iparam.\n");
      exit(EXIT_FAILURE);

    }
    /* dparam */
    nval = fscanf(ficin, "%lf%lf%lf", &(options->dparam[0]), &(options->dparam[1]), &(options->dparam[2]));
    if (nval != 3)
    {
      fprintf(stderr, "Numerics, readSolverOptions error, wrong number of parameters for dparam.\n");
      exit(EXIT_FAILURE);

    }
    fclose(ficin);
    break;
  default:
    fprintf(stderr, "Numerics, readSolverOptions error, unknown problem type.\n");
    exit(EXIT_FAILURE);
  }
}
コード例 #11
0
ファイル: proj3io.c プロジェクト: zcsevcik/edu
bool test(const char* filename, FILE* fout)
{
    FILE* fp = fopen(filename, "r");
    if (fp == NULL) {
        perror(filename);
        return false;
    }

    int fmt;

    int suc = fscanf(fp, "%d", &fmt);
    if (suc == EOF || suc != 1) {
        fclose(fp);
        return false;
    }
    if (fclose(fp) != 0) {
        perror(filename);
    }

    switch (fmt) {
        case FMT_VECTOR: {
            Vector vect = { .count = 0, .items = NULL };
            if (!vector_load(&vect, filename)) {
                return false;
            }

            vector_print(&vect, fout);
            vector_free(&vect);
        }   break;

        case FMT_MATRIX: {
            Matrix mat = { .rows = 0, .cols = 0, .items = NULL };
            if (!matrix_load(&mat, filename)) {
                return false;
            }

            matrix_print(&mat, fout);
            matrix_free(&mat);
        }   break;

        case FMT_VECTOR_OF_MATRICES: {
            VectorOfMatrices vm = { .count = 0, .rows = 0, .cols = 0, .items = NULL };
            if (!vm_load(&vm, filename)) {
                return false;
            }

            vm_print(&vm, fout);
            vm_free(&vm);
        }   break;

        default:
            return false;
    }

    return true;
}

bool vector_load(Vector* vect, const char* filename)
{
    assert(vect != NULL);

    FILE* fp = fopen(filename, "r");
    if (fp == NULL) {
        perror(filename);
        goto return_false;
    }

    int fmt;
    unsigned long count;

    int suc = fscanf(fp, "%d", &fmt);
    CHECK_IO(suc, 1, return_false);
    if (fmt != FMT_VECTOR) {
        goto return_false;
    }

    suc = fscanf(fp, "%lu", &count);
    CHECK_IO(suc, 1, return_false);
    if (count <= 0) {
        goto return_false;
    }
    vect->count = count;
    if (!vector_alloc(vect)) {
        goto return_false;
    }

    int* pVect = vect->items;
    for (size_t i = 0; i < vect->count; ++i) {
        suc = fscanf(fp, "%d", pVect++);
        CHECK_IO(suc, 1, return_false);
    }

    if (fclose(fp) != 0) {
        perror(filename);
    }

    return true;

return_false:
    if (fp != NULL && fclose(fp) != 0) {
        perror(filename);
    }

    vector_free(vect);
    return false;
}

void vector_print(const Vector* vect, FILE* fp)
{
    assert(vect != NULL);
    assert(fp != NULL);
    assert(vect->count > 0);
    assert(vect->items != NULL);

    fprintf(fp, "%d\n", FMT_VECTOR);
    fprintf(fp, "%zu\n", vect->count);

    int* pVect = vect->items;
    for (size_t i = 0; i < vect->count; ++i) {
        fprintf(fp, "%d ", *pVect++);
    }
}

void noop_print(FILE* fp)
{
    assert(fp != NULL);
    fprintf(fp, "false\n");
}
コード例 #12
0
int mixedLinearComplementarity_newFromFileOld(MixedLinearComplementarityProblem* problem, FILE* file)
{
  int n = 0, m = 0, NbLines = 0;
  int i, j,  m2;
  char val[128];

  double *vecA, *vecB, *vecC, *vecD, *vecM, *vecQ;
  double *a, *b;
  CHECK_IO(fscanf(file , "%d" , &n));
  CHECK_IO(fscanf(file , "%d" , &m));
  CHECK_IO(fscanf(file , "%d" , &NbLines));

  m2 = m * m;

  vecM = (double*)malloc((n + m) * (NbLines) * sizeof(double));

  vecQ = (double*)malloc((NbLines) * sizeof(double));
  vecA = (double*)malloc(n * (NbLines - m) * sizeof(double));
  vecB = (double*)malloc(m2 * sizeof(double));
  vecC = (double*)malloc((NbLines - m) * m * sizeof(double));
  vecD = (double*)malloc(m * n * sizeof(double));
  a    = (double*)malloc((NbLines - m) * sizeof(double));
  b    = (double*)malloc(m * sizeof(double));

  problem->blocksRows = (int*)malloc(3 * sizeof(int));
  problem->blocksIsComp = (int*)malloc(2 * sizeof(int));
  problem->blocksRows[0] = 0;
  problem->blocksRows[1] = n;
  problem->blocksRows[2] = n + m;
  problem->blocksIsComp[0] = 0;
  problem->blocksIsComp[1] = 1;





  problem->M = createNumericsMatrixFromData(NM_DENSE, NbLines, n + m, vecM);

  problem->isStorageType1 = 1; // Both problems seems to be stored
  problem->isStorageType2 = 1; // Both problems seems to be stored

  problem->q = vecQ;
  problem->A = vecA;
  problem->B = vecB;
  problem->C = vecC;
  problem->D = vecD;
  problem->a = a;
  problem->b = b;
  problem->blocksRows[1] = n;
  problem->blocksRows[2] = n + m;
  problem->n = n;
  problem->m = m;



  for (i = 0 ; i < NbLines - m ; ++i)
  {
    for (j = 0 ; j < n ; ++j)
    {
      CHECK_IO(fscanf(file, "%s", val));
      vecA[(NbLines - m)*j + i ] = atof(val);
      vecM[(NbLines)*j + i ] = atof(val);
    }
  }
  for (i = 0 ; i < m ; ++i)
  {
    for (j = 0 ; j < m ; ++j)
    {
      CHECK_IO(fscanf(file, "%s", val));
      vecB[ m * j + i ] = atof(val);
      /*  vecM[ n*(m+n)+(n+m)*j+n+i ] = atof(val);*/
      vecM[ n * (NbLines) + (NbLines)*j + (NbLines - m) + i ] = atof(val);

    }
  }
  for (i = 0 ; i < NbLines - m ; ++i)
  {
    for (j = 0 ; j < m ; ++j)
    {
      CHECK_IO(fscanf(file, "%s", val));
      vecC[(NbLines - m)*j + i ] = atof(val);
      vecM[(NbLines) * (n + j) + i ] = atof(val);
    }
  }
  for (i = 0 ; i < m ; ++i)
  {
    for (j = 0 ; j < n ; ++j)
    {
      CHECK_IO(fscanf(file, "%s", val));
      vecD[ m * j + i ] = atof(val);
      vecM[(NbLines)*j + i + (NbLines - m) ] = atof(val);
    }
  }

  for (i = 0 ; i < NbLines - m ; ++i)
  {
    CHECK_IO(fscanf(file , "%s" , val));
    a[i] = atof(val);
    vecQ[i] = atof(val);
  }
  for (i = 0 ; i < m ; ++i)
  {
    CHECK_IO(fscanf(file , "%s" , val));
    b[i] = atof(val);
    vecQ[i + NbLines - m] = atof(val);
  }

  return 0;
}
コード例 #13
0
int mixedLinearComplementarity_newFromFile(MixedLinearComplementarityProblem* problem, FILE* file)
{
  int info = 0;
  assert(file);
  if (! problem)
  {
    fprintf(stderr, "Numerics, MixedLinearComplementarityProblem printInFile failed, NULL input.\n");
    exit(EXIT_FAILURE);
  }
  int i, j;
  int st1, st2;
  CHECK_IO(fscanf(file, "%d\n", &st1));
  problem->isStorageType1 = st1;
  CHECK_IO(fscanf(file, "%d\n", &st2));
  problem->isStorageType2 = st2;

  int n ;
  CHECK_IO(fscanf(file, "%d\n", &n));
  problem->n = n;
  int m;
  CHECK_IO(fscanf(file, "%d\n", &m));
  problem->m = m;



  if (problem->isStorageType1)
  {
    int * blocksRows = (int *)malloc((n + m + 1) * sizeof(int));
    int nbBlocks = 0;
    CHECK_IO(fscanf(file, "%d ", &(blocksRows[nbBlocks])));
    while (blocksRows[nbBlocks] < (n + m))
    {
      nbBlocks++;
      CHECK_IO(fscanf(file, "%d ", &(blocksRows[nbBlocks])));
    }
    problem->blocksRows = (int *)malloc((nbBlocks + 1) * sizeof(int));
    //CHECK_IO(fscanf(file,"\n"));
    for (i = 0; i <= nbBlocks; i++)
    {
      problem->blocksRows[i] = blocksRows[i];
    }
    free(blocksRows);
    problem->blocksIsComp = (int *)malloc((nbBlocks) * sizeof(int));

    //fprintf(file,"\n");
    for (i = 0; i < nbBlocks; i++)
    {
      CHECK_IO(fscanf(file, "%d ", &(problem->blocksIsComp[i])));
    }

    //fprintf(file,"\n");
    problem->M = newNumericsMatrix();
    newFromFile(problem->M, file);
    problem->q = (double *) malloc(problem->M->size1 * sizeof(double));

    for (i = 0; i < problem->M->size1; i++)
    {
      CHECK_IO(fscanf(file, "%lf ", &(problem->q[i])));
    }
    //fprintf(file,"\n");
    /* return 1; */
    /* if (problem->isStorageType2)  */
    /* { */
    /*   printf("Numerics, MixedLinearComplementarityProblem printInFile only Storage1 has been printed.\n"); */
    /* } */
  }
  if (problem->isStorageType2)
  {

    problem->A = (double*)malloc(n * n * sizeof(double));
    problem->B = (double*)malloc(m * m * sizeof(double));
    problem->C = (double*)malloc(n * m * sizeof(double));
    problem->D = (double*)malloc(m * n * sizeof(double));
    problem->a = (double*)malloc(n * sizeof(double));
    problem->b = (double*)malloc(m * sizeof(double));

    for (i = 0; i < problem->n; i++)
    {
      for (j = 0; j < problem->n; j++)
      {
        CHECK_IO(fscanf(file, "%lf ", &(problem->A[i + j * n])));
      }
      /* CHECK_IO(fscanf(file,"\n")); */
    }

    for (i = 0; i < problem->m; i++)
    {
      for (j = 0; j < problem->m; j++)
      {
        CHECK_IO(fscanf(file, "%lf ", &(problem->B[i + j * m])));
      }
      /* fprintf(file,"\n"); */
    }
    for (i = 0; i < problem->n; i++)
    {
      for (j = 0; j < problem->m; j++)
      {
        CHECK_IO(fscanf(file, "%lf ", &(problem->C[i + j * n])));
      }
      /* fprintf(file,"\n"); */
    }
    for (i = 0; i < problem->m; i++)
    {
      for (j = 0; j < problem->n; j++)
      {
        CHECK_IO(fscanf(file, "%lf ", &(problem->D[i + j * m])));
      }
      /* fprintf(file,"\n"); */
    }

    for (i = 0; i < problem->n; i++)
    {
      CHECK_IO(fscanf(file, "%lf ", &(problem->a[i])));
    }
    /* fprintf(file,"\n"); */
    for (i = 0; i < problem->m; i++)
    {
      CHECK_IO(fscanf(file, "%lf ", &(problem->b[i])));
    }

  }
  return info;

}