Ticket #45101: patch-SuiteSparse.diff

File patch-SuiteSparse.diff, 9.6 KB (added by michaelld (Michael Dickens), 10 years ago)

Patch to Octave 3.8.[12] for SuiteSparse 4.3 API

  • libinterp/dldfcn/amd.cc

    old new  
    164164
    165165              // FIXME: how can we manage the memory allocation of amd
    166166              //        in a cleaner manner?
    167               amd_malloc = malloc;
    168               amd_free = free;
    169               amd_calloc = calloc;
    170               amd_realloc = realloc;
    171               amd_printf = printf;
     167              SUITESPARSE_ASSIGN_FPTR (malloc_func, amd_malloc, malloc);
     168              SUITESPARSE_ASSIGN_FPTR (free_func, amd_free, free);
     169              SUITESPARSE_ASSIGN_FPTR (calloc_func, amd_calloc, calloc);
     170              SUITESPARSE_ASSIGN_FPTR (realloc_func, amd_realloc, realloc);
     171              SUITESPARSE_ASSIGN_FPTR (printf_func, amd_printf, printf);
    172172
    173173              octave_idx_type result = AMD_NAME (_order) (n_col, cidx, ridx, P,
    174174                                                          Control, Info);

  • libinterp/dldfcn/symbfact.cc

    old new  
    114114  if (spu == 0.)
    115115    {
    116116      cm->print = -1;
    117       cm->print_function = 0;
     117      SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, 0);
    118118    }
    119119  else
    120120    {
    121121      cm->print = static_cast<int> (spu) + 2;
    122       cm->print_function =&SparseCholPrint;
     122      SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, &SparseCholPrint);
    123123    }
    124124
    125125  cm->error_handler = &SparseCholError;
    126   cm->complex_divide = CHOLMOD_NAME(divcomplex);
    127   cm->hypotenuse = CHOLMOD_NAME(hypot);
     126  SUITESPARSE_ASSIGN_FPTR2 (divcomplex_func, cm->complex_divide, divcomplex);
     127  SUITESPARSE_ASSIGN_FPTR2 (hypot_func, cm->hypotenuse, hypot);
    128128
    129129  double dummy;
    130130  cholmod_sparse Astore;

  • liboctave/array/CSparse.cc

    old new  
    56695669          if (spu == 0.)
    56705670            {
    56715671              cm->print = -1;
    5672               cm->print_function = 0;
     5672              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, 0);
    56735673            }
    56745674          else
    56755675            {
    56765676              cm->print = static_cast<int> (spu) + 2;
    5677               cm->print_function =&SparseCholPrint;
     5677              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, &SparseCholPrint);
    56785678            }
    56795679
    56805680          cm->error_handler = &SparseCholError;
    5681           cm->complex_divide = CHOLMOD_NAME(divcomplex);
    5682           cm->hypotenuse = CHOLMOD_NAME(hypot);
     5681          SUITESPARSE_ASSIGN_FPTR2 (divcomplex_func, cm->complex_divide, divcomplex);
     5682          SUITESPARSE_ASSIGN_FPTR2 (hypot_func, cm->hypotenuse, hypot);
    56835683
    56845684          cm->final_ll = true;
    56855685
    … …  
    59125912          if (spu == 0.)
    59135913            {
    59145914              cm->print = -1;
    5915               cm->print_function = 0;
     5915              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, 0);
    59165916            }
    59175917          else
    59185918            {
    59195919              cm->print = static_cast<int> (spu) + 2;
    5920               cm->print_function =&SparseCholPrint;
     5920              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, &SparseCholPrint);
    59215921            }
    59225922
    59235923          cm->error_handler = &SparseCholError;
    5924           cm->complex_divide = CHOLMOD_NAME(divcomplex);
    5925           cm->hypotenuse = CHOLMOD_NAME(hypot);
     5924          SUITESPARSE_ASSIGN_FPTR2 (divcomplex_func, cm->complex_divide, divcomplex);
     5925          SUITESPARSE_ASSIGN_FPTR2 (hypot_func, cm->hypotenuse, hypot);
    59265926
    59275927          cm->final_ll = true;
    59285928
    … …  
    62036203          if (spu == 0.)
    62046204            {
    62056205              cm->print = -1;
    6206               cm->print_function = 0;
     6206              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, 0);
    62076207            }
    62086208          else
    62096209            {
    62106210              cm->print = static_cast<int> (spu) + 2;
    6211               cm->print_function =&SparseCholPrint;
     6211              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, &SparseCholPrint);
    62126212            }
    62136213
    62146214          cm->error_handler = &SparseCholError;
    6215           cm->complex_divide = CHOLMOD_NAME(divcomplex);
    6216           cm->hypotenuse = CHOLMOD_NAME(hypot);
     6215          SUITESPARSE_ASSIGN_FPTR2 (divcomplex_func, cm->complex_divide, divcomplex);
     6216          SUITESPARSE_ASSIGN_FPTR2 (hypot_func, cm->hypotenuse, hypot);
    62176217
    62186218          cm->final_ll = true;
    62196219
    … …  
    64256425          if (spu == 0.)
    64266426            {
    64276427              cm->print = -1;
    6428               cm->print_function = 0;
     6428              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, 0);
    64296429            }
    64306430          else
    64316431            {
    64326432              cm->print = static_cast<int> (spu) + 2;
    6433               cm->print_function =&SparseCholPrint;
     6433              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, &SparseCholPrint);
    64346434            }
    64356435
    64366436          cm->error_handler = &SparseCholError;
    6437           cm->complex_divide = CHOLMOD_NAME(divcomplex);
    6438           cm->hypotenuse = CHOLMOD_NAME(hypot);
     6437          SUITESPARSE_ASSIGN_FPTR2 (divcomplex_func, cm->complex_divide, divcomplex);
     6438          SUITESPARSE_ASSIGN_FPTR2 (hypot_func, cm->hypotenuse, hypot);
    64396439
    64406440          cm->final_ll = true;
    64416441

  • liboctave/array/dSparse.cc

    old new  
    58715871          if (spu == 0.)
    58725872            {
    58735873              cm->print = -1;
    5874               cm->print_function = 0;
     5874              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, 0);
    58755875            }
    58765876          else
    58775877            {
    58785878              cm->print = static_cast<int> (spu) + 2;
    5879               cm->print_function =&SparseCholPrint;
     5879              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, &SparseCholPrint);
    58805880            }
    58815881
    58825882          cm->error_handler = &SparseCholError;
    5883           cm->complex_divide = CHOLMOD_NAME(divcomplex);
    5884           cm->hypotenuse = CHOLMOD_NAME(hypot);
     5883          SUITESPARSE_ASSIGN_FPTR2 (divcomplex_func, cm->complex_divide, divcomplex);
     5884          SUITESPARSE_ASSIGN_FPTR2 (hypot_func, cm->hypotenuse, hypot);
    58855885
    58865886          cm->final_ll = true;
    58875887
    … …  
    60886088          if (spu == 0.)
    60896089            {
    60906090              cm->print = -1;
    6091               cm->print_function = 0;
     6091              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, 0);
    60926092            }
    60936093          else
    60946094            {
    60956095              cm->print = static_cast<int> (spu) + 2;
    6096               cm->print_function =&SparseCholPrint;
     6096              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, &SparseCholPrint);
    60976097            }
    60986098
    60996099          cm->error_handler = &SparseCholError;
    6100           cm->complex_divide = CHOLMOD_NAME(divcomplex);
    6101           cm->hypotenuse = CHOLMOD_NAME(hypot);
     6100          SUITESPARSE_ASSIGN_FPTR2 (divcomplex_func, cm->complex_divide, divcomplex);
     6101          SUITESPARSE_ASSIGN_FPTR2 (hypot_func, cm->hypotenuse, hypot);
    61026102
    61036103          cm->final_ll = true;
    61046104
    … …  
    63506350          if (spu == 0.)
    63516351            {
    63526352              cm->print = -1;
    6353               cm->print_function = 0;
     6353              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, 0);
    63546354            }
    63556355          else
    63566356            {
    63576357              cm->print = static_cast<int> (spu) + 2;
    6358               cm->print_function =&SparseCholPrint;
     6358              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, &SparseCholPrint);
    63596359            }
    63606360
    63616361          cm->error_handler = &SparseCholError;
    6362           cm->complex_divide = CHOLMOD_NAME(divcomplex);
    6363           cm->hypotenuse = CHOLMOD_NAME(hypot);
     6362          SUITESPARSE_ASSIGN_FPTR2 (divcomplex_func, cm->complex_divide, divcomplex);
     6363          SUITESPARSE_ASSIGN_FPTR2 (hypot_func, cm->hypotenuse, hypot);
    63646364
    63656365          cm->final_ll = true;
    63666366
    … …  
    65846584          if (spu == 0.)
    65856585            {
    65866586              cm->print = -1;
    6587               cm->print_function = 0;
     6587              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, 0);
    65886588            }
    65896589          else
    65906590            {
    65916591              cm->print = static_cast<int> (spu) + 2;
    6592               cm->print_function =&SparseCholPrint;
     6592              SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, &SparseCholPrint);
    65936593            }
    65946594
    65956595          cm->error_handler = &SparseCholError;
    6596           cm->complex_divide = CHOLMOD_NAME(divcomplex);
    6597           cm->hypotenuse = CHOLMOD_NAME(hypot);
     6596          SUITESPARSE_ASSIGN_FPTR2 (divcomplex_func, cm->complex_divide, divcomplex);
     6597          SUITESPARSE_ASSIGN_FPTR2 (hypot_func, cm->hypotenuse, hypot);
    65986598
    65996599          cm->final_ll = true;
    66006600

  • liboctave/numeric/sparse-base-chol.cc

    old new  
    105105  if (spu == 0.)
    106106    {
    107107      cm->print = -1;
    108       cm->print_function = 0;
     108      SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, 0);
    109109    }
    110110  else
    111111    {
    112112      cm->print = static_cast<int> (spu) + 2;
    113       cm->print_function =&SparseCholPrint;
     113      SUITESPARSE_ASSIGN_FPTR (printf_func, cm->print_function, &SparseCholPrint);
    114114    }
    115115
    116116  cm->error_handler = &SparseCholError;
    117   cm->complex_divide = CHOLMOD_NAME(divcomplex);
    118   cm->hypotenuse = CHOLMOD_NAME(hypot);
     117  SUITESPARSE_ASSIGN_FPTR2 (divcomplex_func, cm->complex_divide, divcomplex);
     118  SUITESPARSE_ASSIGN_FPTR2 (hypot_func, cm->hypotenuse, hypot);
    119119
    120120  cm->final_asis = false;
    121121  cm->final_super = false;

  • liboctave/util/oct-sparse.h

    old new  
    9494#endif
    9595#endif
    9696
     97// Cope with new suitesparse versions
     98//
     99#if defined (SUITESPARSE_VERSION) && SUITESPARSE_VERSION >= SUITESPARSE_VER_CODE (4, 3)
     100# define SUITESPARSE_ASSIGN_FPTR(f_name, f_var, f_assign) (SuiteSparse_config.f_name = f_assign)
     101# define SUITESPARSE_ASSIGN_FPTR2(f_name, f_var, f_assign) (SuiteSparse_config.f_name = CHOLMOD_NAME (f_assign))
     102#else
     103# define SUITESPARSE_ASSIGN_FPTR(f_name, f_var, f_assign) (f_var = f_assign)
     104# define SUITESPARSE_ASSIGN_FPTR2(f_name, f_var, f_assign) (f_var = CHOLMOD_NAME (f_assign))
    97105#endif
     106
     107#endif