GNU Octave  4.2.1
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
__glpk__.cc
Go to the documentation of this file.
1 /*
2 
3 Copyright (C) 2005-2017 Nicolo' Giorgetti
4 Copyright (C) 2013-2016 S├ębastien Villemot <sebastien@debian.org>
5 
6 This file is part of Octave.
7 
8 Octave is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 3 of the License, or (at your
11 option) any later version.
12 
13 Octave is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17 
18 You should have received a copy of the GNU General Public License
19 along with Octave; see the file COPYING. If not, see
20 <http://www.gnu.org/licenses/>.
21 
22 */
23 
24 #if defined (HAVE_CONFIG_H)
25 # include "config.h"
26 #endif
27 
28 #include <cfloat>
29 #include <ctime>
30 
31 #include "lo-ieee.h"
32 
33 #include "defun-dld.h"
34 #include "error.h"
35 #include "errwarn.h"
36 #include "oct-map.h"
37 #include "ovl.h"
38 #include "pager.h"
39 
40 #if defined (HAVE_GLPK)
41 
42 extern "C"
43 {
44 #if defined (HAVE_GLPK_GLPK_H)
45 # include <glpk/glpk.h>
46 #else
47 # include <glpk.h>
48 #endif
49 }
50 
52 {
53  int msglev;
54  int dual;
55  int price;
56  int itlim;
57  int outfrq;
58  int branch;
59  int btrack;
60  int presol;
61  int rtest;
62  int tmlim;
63  int outdly;
64  double tolbnd;
65  double toldj;
66  double tolpiv;
67  double objll;
68  double objul;
69  double tolint;
70  double tolobj;
71 };
72 
73 int
74 glpk (int sense, int n, int m, double *c, int nz, int *rn, int *cn,
75  double *a, double *b, char *ctype, int *freeLB, double *lb,
76  int *freeUB, double *ub, int *vartype, int isMIP, int lpsolver,
77  int save_pb, int scale, const control_params *par,
78  double *xmin, double *fmin, int *status,
79  double *lambda, double *redcosts, double *time)
80 {
81  int typx = 0;
82  int errnum = 0;
83 
84  clock_t t_start = clock ();
85 
86  glp_prob *lp = glp_create_prob ();
87 
88  // Set the sense of optimization
89  if (sense == 1)
90  glp_set_obj_dir (lp, GLP_MIN);
91  else
92  glp_set_obj_dir (lp, GLP_MAX);
93 
94  glp_add_cols (lp, n);
95  for (int i = 0; i < n; i++)
96  {
97  // Define type of the structural variables
98  if (! freeLB[i] && ! freeUB[i])
99  {
100  if (lb[i] != ub[i])
101  glp_set_col_bnds (lp, i+1, GLP_DB, lb[i], ub[i]);
102  else
103  glp_set_col_bnds (lp, i+1, GLP_FX, lb[i], ub[i]);
104  }
105  else
106  {
107  if (! freeLB[i] && freeUB[i])
108  glp_set_col_bnds (lp, i+1, GLP_LO, lb[i], ub[i]);
109  else
110  {
111  if (freeLB[i] && ! freeUB[i])
112  glp_set_col_bnds (lp, i+1, GLP_UP, lb[i], ub[i]);
113  else
114  glp_set_col_bnds (lp, i+1, GLP_FR, lb[i], ub[i]);
115  }
116  }
117 
118  // -- Set the objective coefficient of the corresponding
119  // -- structural variable. No constant term is assumed.
120  glp_set_obj_coef(lp,i+1,c[i]);
121 
122  if (isMIP)
123  glp_set_col_kind (lp, i+1, vartype[i]);
124  }
125 
126  glp_add_rows (lp, m);
127 
128  for (int i = 0; i < m; i++)
129  {
130  // If the i-th row has no lower bound (types F,U), the
131  // corrispondent parameter will be ignored. If the i-th row has
132  // no upper bound (types F,L), the corrispondent parameter will be
133  // ignored. If the i-th row is of S type, the i-th LB is used,
134  // but the i-th UB is ignored.
135 
136  switch (ctype[i])
137  {
138  case 'F':
139  typx = GLP_FR;
140  break;
141 
142  case 'U':
143  typx = GLP_UP;
144  break;
145 
146  case 'L':
147  typx = GLP_LO;
148  break;
149 
150  case 'S':
151  typx = GLP_FX;
152  break;
153 
154  case 'D':
155  typx = GLP_DB;
156  break;
157  }
158 
159  glp_set_row_bnds (lp, i+1, typx, b[i], b[i]);
160 
161  }
162 
163  glp_load_matrix (lp, nz, rn, cn, a);
164 
165  if (save_pb)
166  {
167  static char tmp[] = "outpb.lp";
168  if (glp_write_lp (lp, 0, tmp) != 0)
169  error ("__glpk__: unable to write problem");
170  }
171 
172  // scale the problem data
173  if (! par->presol || lpsolver != 1)
174  glp_scale_prob (lp, scale);
175 
176  // build advanced initial basis (if required)
177  if (lpsolver == 1 && ! par->presol)
178  glp_adv_basis (lp, 0);
179 
180  // For MIP problems without a presolver, a first pass with glp_simplex
181  // is required
182  if ((! isMIP && lpsolver == 1)
183  || (isMIP && ! par->presol))
184  {
185  glp_smcp smcp;
186  glp_init_smcp (&smcp);
187  smcp.msg_lev = par->msglev;
188  smcp.meth = par->dual;
189  smcp.pricing = par->price;
190  smcp.r_test = par->rtest;
191  smcp.tol_bnd = par->tolbnd;
192  smcp.tol_dj = par->toldj;
193  smcp.tol_piv = par->tolpiv;
194  smcp.obj_ll = par->objll;
195  smcp.obj_ul = par->objul;
196  smcp.it_lim = par->itlim;
197  smcp.tm_lim = par->tmlim;
198  smcp.out_frq = par->outfrq;
199  smcp.out_dly = par->outdly;
200  smcp.presolve = par->presol;
201  errnum = glp_simplex (lp, &smcp);
202  }
203 
204  if (isMIP)
205  {
206  glp_iocp iocp;
207  glp_init_iocp (&iocp);
208  iocp.msg_lev = par->msglev;
209  iocp.br_tech = par->branch;
210  iocp.bt_tech = par->btrack;
211  iocp.tol_int = par->tolint;
212  iocp.tol_obj = par->tolobj;
213  iocp.tm_lim = par->tmlim;
214  iocp.out_frq = par->outfrq;
215  iocp.out_dly = par->outdly;
216  iocp.presolve = par->presol;
217  errnum = glp_intopt (lp, &iocp);
218  }
219 
220  if (! isMIP && lpsolver == 2)
221  {
222  glp_iptcp iptcp;
223  glp_init_iptcp (&iptcp);
224  iptcp.msg_lev = par->msglev;
225  errnum = glp_interior (lp, &iptcp);
226  }
227 
228  if (errnum == 0)
229  {
230  if (isMIP)
231  {
232  *status = glp_mip_status (lp);
233  *fmin = glp_mip_obj_val (lp);
234  }
235  else
236  {
237  if (lpsolver == 1)
238  {
239  *status = glp_get_status (lp);
240  *fmin = glp_get_obj_val (lp);
241  }
242  else
243  {
244  *status = glp_ipt_status (lp);
245  *fmin = glp_ipt_obj_val (lp);
246  }
247  }
248 
249  if (isMIP)
250  {
251  for (int i = 0; i < n; i++)
252  xmin[i] = glp_mip_col_val (lp, i+1);
253  }
254  else
255  {
256  // Primal values
257  for (int i = 0; i < n; i++)
258  {
259  if (lpsolver == 1)
260  xmin[i] = glp_get_col_prim (lp, i+1);
261  else
262  xmin[i] = glp_ipt_col_prim (lp, i+1);
263  }
264 
265  // Dual values
266  for (int i = 0; i < m; i++)
267  {
268  if (lpsolver == 1)
269  lambda[i] = glp_get_row_dual (lp, i+1);
270  else
271  lambda[i] = glp_ipt_row_dual (lp, i+1);
272  }
273 
274  // Reduced costs
275  for (int i = 0; i < glp_get_num_cols (lp); i++)
276  {
277  if (lpsolver == 1)
278  redcosts[i] = glp_get_col_dual (lp, i+1);
279  else
280  redcosts[i] = glp_ipt_col_dual (lp, i+1);
281  }
282  }
283 
284  *time = (clock () - t_start) / CLOCKS_PER_SEC;
285  }
286 
287  glp_delete_prob (lp);
288  // Request that GLPK free all memory resources.
289  // This prevents reported memory leaks, but isn't strictly necessary.
290  // The memory blocks use are allocated once and don't grow with further
291  // calls to glpk so they would be reclaimed anyways when Octave exits.
292  glp_free_env ();
293 
294  return errnum;
295 }
296 
297 #endif
298 
299 #define OCTAVE_GLPK_GET_REAL_PARAM(NAME, VAL) \
300  do \
301  { \
302  octave_value tmp = PARAM.getfield (NAME); \
303  \
304  if (tmp.is_defined ()) \
305  { \
306  if (! tmp.is_empty ()) \
307  VAL = tmp.xscalar_value ("glpk: invalid value in PARAM" NAME); \
308  else \
309  error ("glpk: invalid value in PARAM" NAME); \
310  } \
311  } \
312  while (0)
313 
314 #define OCTAVE_GLPK_GET_INT_PARAM(NAME, VAL) \
315  do \
316  { \
317  octave_value tmp = PARAM.getfield (NAME); \
318  \
319  if (tmp.is_defined ()) \
320  { \
321  if (! tmp.is_empty ()) \
322  VAL = tmp.xint_value ("glpk: invalid value in PARAM" NAME); \
323  else \
324  error ("glpk: invalid value in PARAM" NAME); \
325  } \
326  } \
327  while (0)
328 
329 DEFUN_DLD (__glpk__, args, ,
330  doc: /* -*- texinfo -*-
331 @deftypefn {} {[@var{values}] =} __glpk__ (@var{args})
332 Undocumented internal function.
333 @end deftypefn */)
334 {
335 #if defined (HAVE_GLPK)
336 
337  // FIXME: Should we even need checking for an internal function?
338  if (args.length () != 9)
339  print_usage ();
340 
341  // 1nd Input. A column array containing the objective function coefficients.
342  int mrowsc = args(0).rows ();
343 
344  Matrix C = args(0).xmatrix_value ("__glpk__: invalid value of C");
345 
346  double *c = C.fortran_vec ();
347  Array<int> rn;
348  Array<int> cn;
349  ColumnVector a;
350  int mrowsA;
351  int nz = 0;
352 
353  // 2nd Input. A matrix containing the constraints coefficients.
354  // If matrix A is NOT a sparse matrix
355  if (args(1).is_sparse_type ())
356  {
357  SparseMatrix A = args(1).xsparse_matrix_value ("__glpk__: invalid value of A");
358 
359  mrowsA = A.rows ();
360  octave_idx_type Anc = A.cols ();
361  octave_idx_type Anz = A.nnz ();
362  rn.resize (dim_vector (Anz+1, 1));
363  cn.resize (dim_vector (Anz+1, 1));
364  a.resize (Anz+1, 0.0);
365 
366  if (Anc != mrowsc)
367  error ("__glpk__: invalid value of A");
368 
369  for (octave_idx_type j = 0; j < Anc; j++)
370  for (octave_idx_type i = A.cidx (j); i < A.cidx (j+1); i++)
371  {
372  nz++;
373  rn(nz) = A.ridx (i) + 1;
374  cn(nz) = j + 1;
375  a(nz) = A.data(i);
376  }
377  }
378  else
379  {
380  Matrix A = args(1).xmatrix_value ("__glpk__: invalid value of A");
381 
382  mrowsA = A.rows ();
383  rn.resize (dim_vector (mrowsA*mrowsc+1, 1));
384  cn.resize (dim_vector (mrowsA*mrowsc+1, 1));
385  a.resize (mrowsA*mrowsc+1, 0.0);
386 
387  for (int i = 0; i < mrowsA; i++)
388  {
389  for (int j = 0; j < mrowsc; j++)
390  {
391  if (A(i,j) != 0)
392  {
393  nz++;
394  rn(nz) = i + 1;
395  cn(nz) = j + 1;
396  a(nz) = A(i,j);
397  }
398  }
399  }
400 
401  }
402 
403  // 3rd Input. A column array containing the right-hand side value
404  // for each constraint in the constraint matrix.
405  Matrix B = args(2).xmatrix_value ("__glpk__: invalid value of B");
406 
407  double *b = B.fortran_vec ();
408 
409  // 4th Input. An array of length mrowsc containing the lower
410  // bound on each of the variables.
411  Matrix LB = args(3).xmatrix_value ("__glpk__: invalid value of LB");
412 
413  if (LB.numel () < mrowsc)
414  error ("__glpk__: invalid dimensions for LB");
415 
416  double *lb = LB.fortran_vec ();
417 
418  // LB argument, default: Free
419  Array<int> freeLB (dim_vector (mrowsc, 1));
420  for (int i = 0; i < mrowsc; i++)
421  {
422  if (octave::math::isinf (lb[i]))
423  {
424  freeLB(i) = 1;
426  }
427  else
428  freeLB(i) = 0;
429  }
430 
431  // 5th Input. An array of at least length numcols containing the upper
432  // bound on each of the variables.
433  Matrix UB = args(4).xmatrix_value ("__glpk__: invalid value of UB");
434 
435  if (UB.numel () < mrowsc)
436  error ("__glpk__: invalid dimensions for UB");
437 
438  double *ub = UB.fortran_vec ();
439 
440  Array<int> freeUB (dim_vector (mrowsc, 1));
441  for (int i = 0; i < mrowsc; i++)
442  {
443  if (octave::math::isinf (ub[i]))
444  {
445  freeUB(i) = 1;
447  }
448  else
449  freeUB(i) = 0;
450  }
451 
452  // 6th Input. A column array containing the sense of each constraint
453  // in the constraint matrix.
454  charMatrix CTYPE = args(5).xchar_matrix_value ("__glpk__: invalid value of CTYPE");
455 
456  char *ctype = CTYPE.fortran_vec ();
457 
458  // 7th Input. A column array containing the types of the variables.
459  charMatrix VTYPE = args(6).xchar_matrix_value ("__glpk__: invalid value of VARTYPE");
460 
461  Array<int> vartype (dim_vector (mrowsc, 1));
462  int isMIP = 0;
463  for (int i = 0; i < mrowsc ; i++)
464  {
465  if (VTYPE(i,0) == 'I')
466  {
467  isMIP = 1;
468  vartype(i) = GLP_IV;
469  }
470  else
471  vartype(i) = GLP_CV;
472  }
473 
474  // 8th Input. Sense of optimization.
475  int sense;
476  double SENSE = args(7).xscalar_value ("__glpk__: invalid value of SENSE");
477 
478  if (SENSE >= 0)
479  sense = 1;
480  else
481  sense = -1;
482 
483  // 9th Input. A structure containing the control parameters.
484  octave_scalar_map PARAM = args(8).xscalar_map_value ("__glpk__: invalid value of PARAM");
485 
486  control_params par;
487 
488  // Integer parameters
489 
490  // Level of messages output by the solver
491  par.msglev = 1;
492  OCTAVE_GLPK_GET_INT_PARAM ("msglev", par.msglev);
493  if (par.msglev < 0 || par.msglev > 3)
494  error ("__glpk__: PARAM.msglev must be 0 (no output) or 1 (error and warning messages only [default]) or 2 (normal output) or 3 (full output)");
495 
496  // scaling option
497  int scale = 16;
498  OCTAVE_GLPK_GET_INT_PARAM ("scale", scale);
499  if (scale < 0 || scale > 128)
500  error ("__glpk__: PARAM.scale must either be 128 (automatic selection of scaling options), or a bitwise or of: 1 (geometric mean scaling), 16 (equilibration scaling), 32 (round scale factors to power of two), 64 (skip if problem is well scaled");
501 
502  // Dual simplex option
503  par.dual = 1;
504  OCTAVE_GLPK_GET_INT_PARAM ("dual", par.dual);
505  if (par.dual < 1 || par.dual > 3)
506  error ("__glpk__: PARAM.dual must be 1 (use two-phase primal simplex [default]) or 2 (use two-phase dual simplex) or 3 (use two-phase dual simplex, and if it fails, switch to the primal simplex)");
507 
508  // Pricing option
509  par.price = 34;
510  OCTAVE_GLPK_GET_INT_PARAM ("price", par.price);
511  if (par.price != 17 && par.price != 34)
512  error ("__glpk__: PARAM.price must be 17 (textbook pricing) or 34 (steepest edge pricing [default])");
513 
514  // Simplex iterations limit
516  OCTAVE_GLPK_GET_INT_PARAM ("itlim", par.itlim);
517 
518  // Output frequency, in iterations
519  par.outfrq = 200;
520  OCTAVE_GLPK_GET_INT_PARAM ("outfrq", par.outfrq);
521 
522  // Branching heuristic option
523  par.branch = 4;
524  OCTAVE_GLPK_GET_INT_PARAM ("branch", par.branch);
525  if (par.branch < 1 || par.branch > 5)
526  error ("__glpk__: PARAM.branch must be 1 (first fractional variable) or 2 (last fractional variable) or 3 (most fractional variable) or 4 (heuristic by Driebeck and Tomlin [default]) or 5 (hybrid pseudocost heuristic)");
527 
528  // Backtracking heuristic option
529  par.btrack = 4;
530  OCTAVE_GLPK_GET_INT_PARAM ("btrack", par.btrack);
531  if (par.btrack < 1 || par.btrack > 4)
532  error ("__glpk__: PARAM.btrack must be 1 (depth first search) or 2 (breadth first search) or 3 (best local bound) or 4 (best projection heuristic [default]");
533 
534  // Presolver option
535  par.presol = 1;
536  OCTAVE_GLPK_GET_INT_PARAM ("presol", par.presol);
537  if (par.presol < 0 || par.presol > 1)
538  error ("__glpk__: PARAM.presol must be 0 (do NOT use LP presolver) or 1 (use LP presolver [default])");
539 
540  // LPsolver option
541  int lpsolver = 1;
542  OCTAVE_GLPK_GET_INT_PARAM ("lpsolver", lpsolver);
543  if (lpsolver < 1 || lpsolver > 2)
544  error ("__glpk__: PARAM.lpsolver must be 1 (simplex method) or 2 (interior point method)");
545 
546  // Ratio test option
547  par.rtest = 34;
548  OCTAVE_GLPK_GET_INT_PARAM ("rtest", par.rtest);
549  if (par.rtest != 17 && par.rtest != 34)
550  error ("__glpk__: PARAM.rtest must be 17 (standard ratio test) or 34 (Harris' two-pass ratio test [default])");
551 
553  OCTAVE_GLPK_GET_INT_PARAM ("tmlim", par.tmlim);
554 
555  par.outdly = 0;
556  OCTAVE_GLPK_GET_INT_PARAM ("outdly", par.outdly);
557 
558  // Save option
559  int save_pb = 0;
560  OCTAVE_GLPK_GET_INT_PARAM ("save", save_pb);
561  save_pb = save_pb != 0;
562 
563  // Real parameters
564 
565  // Relative tolerance used to check if the current basic solution
566  // is primal feasible
567  par.tolbnd = 1e-7;
568  OCTAVE_GLPK_GET_REAL_PARAM ("tolbnd", par.tolbnd);
569 
570  // Absolute tolerance used to check if the current basic solution
571  // is dual feasible
572  par.toldj = 1e-7;
573  OCTAVE_GLPK_GET_REAL_PARAM ("toldj", par.toldj);
574 
575  // Relative tolerance used to choose eligible pivotal elements of
576  // the simplex table in the ratio test
577  par.tolpiv = 1e-10;
578  OCTAVE_GLPK_GET_REAL_PARAM ("tolpiv", par.tolpiv);
579 
581  OCTAVE_GLPK_GET_REAL_PARAM ("objll", par.objll);
582 
584  OCTAVE_GLPK_GET_REAL_PARAM ("objul", par.objul);
585 
586  par.tolint = 1e-5;
587  OCTAVE_GLPK_GET_REAL_PARAM ("tolint", par.tolint);
588 
589  par.tolobj = 1e-7;
590  OCTAVE_GLPK_GET_REAL_PARAM ("tolobj", par.tolobj);
591 
592  // Assign pointers to the output parameters
593  ColumnVector xmin (mrowsc, octave_NA);
594  double fmin = octave_NA;
595  ColumnVector lambda (mrowsA, octave_NA);
596  ColumnVector redcosts (mrowsc, octave_NA);
597  double time;
598  int status;
599 
600  int errnum = glpk (sense, mrowsc, mrowsA, c, nz, rn.fortran_vec (),
601  cn.fortran_vec (), a.fortran_vec (), b, ctype,
602  freeLB.fortran_vec (), lb, freeUB.fortran_vec (),
603  ub, vartype.fortran_vec (), isMIP, lpsolver,
604  save_pb, scale, &par, xmin.fortran_vec (), &fmin,
605  &status, lambda.fortran_vec (),
606  redcosts.fortran_vec (), &time);
607 
608  octave_scalar_map extra;
609 
610  if (! isMIP)
611  {
612  extra.assign ("lambda", lambda);
613  extra.assign ("redcosts", redcosts);
614  }
615 
616  extra.assign ("time", time);
617  extra.assign ("status", status);
618 
619  return ovl (xmin, fmin, errnum, extra);
620 
621 #else
622 
623  octave_unused_parameter (args);
624 
625  err_disabled_feature ("glpk", "GNU Linear Programming Kit");
626 
627 #endif
628 }
629 
630 /*
631 ## No test needed for internal helper function.
632 %!assert (1)
633 */
double objll
Definition: __glpk__.cc:67
octave_idx_type cols(void) const
Definition: Sparse.h:272
double objul
Definition: __glpk__.cc:68
T * data(void)
Definition: Sparse.h:521
octave_idx_type rows(void) const
Definition: Sparse.h:271
#define C(a, b)
Definition: Faddeeva.cc:246
OCTAVE_EXPORT octave_value_list isa nd deftypefn *return ovl(args(0).is_integer_type())
OCTINTERP_API void print_usage(void)
Definition: defun.cc:52
octave_idx_type numel(void) const
Number of elements in the array.
Definition: Array.h:363
int glpk(int sense, int n, int m, double *c, int nz, int *rn, int *cn, double *a, double *b, char *ctype, int *freeLB, double *lb, int *freeUB, double *ub, int *vartype, int isMIP, int lpsolver, int save_pb, int scale, const control_params *par, double *xmin, double *fmin, int *status, double *lambda, double *redcosts, double *time)
Definition: __glpk__.cc:74
void error(const char *fmt,...)
Definition: error.cc:570
octave_idx_type * cidx(void)
Definition: Sparse.h:543
i e
Definition: data.cc:2724
octave_idx_type rows(void) const
Definition: Array.h:401
octave_idx_type nnz(void) const
Actual number of nonzero terms.
Definition: Sparse.h:253
calling an anonymous function involves an overhead quite comparable to the overhead of an m file function Passing a handle to a built in function is because the interpreter is not involved in the internal loop For a
Definition: cellfun.cc:398
JNIEnv void * args
Definition: ov-java.cc:67
F77_RET_T const F77_INT F77_CMPLX const F77_INT F77_CMPLX * B
#define OCTAVE_GLPK_GET_INT_PARAM(NAME, VAL)
Definition: __glpk__.cc:314
nd deftypefn *octave_map m
Definition: ov-struct.cc:2058
#define OCTAVE_GLPK_GET_REAL_PARAM(NAME, VAL)
Definition: __glpk__.cc:299
void resize(const dim_vector &dv, const T &rfv)
Definition: Array.cc:1028
double tmp
Definition: data.cc:6300
#define octave_NA
Definition: lo-ieee.h:36
Definition: dMatrix.h:37
double tolint
Definition: __glpk__.cc:69
the sparsity preserving column transformation such that that defines the pivoting threshold can be given in which case it defines the c
Definition: lu.cc:138
bool isinf(double x)
Definition: lo-mappers.cc:387
octave_int< T > xmin(const octave_int< T > &x, const octave_int< T > &y)
charNDArray max(char d, const charNDArray &m)
Definition: chNDArray.cc:228
#define Inf
Definition: Faddeeva.cc:247
octave_idx_type * ridx(void)
Definition: Sparse.h:530
double tolbnd
Definition: __glpk__.cc:64
=val(i)}if ode{val(i)}occurs in table i
Definition: lookup.cc:239
void assign(const std::string &k, const octave_value &val)
Definition: oct-map.h:223
void scale(Matrix &m, double x, double y, double z)
Definition: graphics.cc:5150
b
Definition: cellfun.cc:398
double tolobj
Definition: __glpk__.cc:70
double toldj
Definition: __glpk__.cc:65
#define DEFUN_DLD(name, args_name, nargout_name, doc)
Definition: defun-dld.h:45
const T * fortran_vec(void) const
Definition: Array.h:584
Vector representing the dimensions (size) of an Array.
Definition: dim-vector.h:87
double tolpiv
Definition: __glpk__.cc:66
void err_disabled_feature(const std::string &fcn, const std::string &feature, const std::string &pkg)
Definition: errwarn.cc:50
void resize(octave_idx_type n, const double &rfv=0)
Definition: dColVector.h:108
F77_RET_T const F77_INT F77_CMPLX * A