OR-Tools  9.2
linear_solver_csharp_wrap.cc
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 4.0.2
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11
12#ifndef SWIGCSHARP
13#define SWIGCSHARP
14#endif
15
16
17
18#ifdef __cplusplus
19/* SwigValueWrapper is described in swig.swg */
20template<typename T> class SwigValueWrapper {
21 struct SwigMovePointer {
22 T *ptr;
23 SwigMovePointer(T *p) : ptr(p) { }
24 ~SwigMovePointer() { delete ptr; }
25 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
26 } pointer;
27 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
28 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
29public:
30 SwigValueWrapper() : pointer(0) { }
31 SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
32 operator T&() const { return *pointer.ptr; }
33 T *operator&() { return pointer.ptr; }
34};
35
36template <typename T> T SwigValueInit() {
37 return T();
38}
39#endif
40
41/* -----------------------------------------------------------------------------
42 * This section contains generic SWIG labels for method/variable
43 * declarations/attributes, and other compiler dependent labels.
44 * ----------------------------------------------------------------------------- */
45
46/* template workaround for compilers that cannot correctly implement the C++ standard */
47#ifndef SWIGTEMPLATEDISAMBIGUATOR
48# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
49# define SWIGTEMPLATEDISAMBIGUATOR template
50# elif defined(__HP_aCC)
51/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
52/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
53# define SWIGTEMPLATEDISAMBIGUATOR template
54# else
55# define SWIGTEMPLATEDISAMBIGUATOR
56# endif
57#endif
58
59/* inline attribute */
60#ifndef SWIGINLINE
61# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
62# define SWIGINLINE inline
63# else
64# define SWIGINLINE
65# endif
66#endif
67
68/* attribute recognised by some compilers to avoid 'unused' warnings */
69#ifndef SWIGUNUSED
70# if defined(__GNUC__)
71# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
72# define SWIGUNUSED __attribute__ ((__unused__))
73# else
74# define SWIGUNUSED
75# endif
76# elif defined(__ICC)
77# define SWIGUNUSED __attribute__ ((__unused__))
78# else
79# define SWIGUNUSED
80# endif
81#endif
82
83#ifndef SWIG_MSC_UNSUPPRESS_4505
84# if defined(_MSC_VER)
85# pragma warning(disable : 4505) /* unreferenced local function has been removed */
86# endif
87#endif
88
89#ifndef SWIGUNUSEDPARM
90# ifdef __cplusplus
91# define SWIGUNUSEDPARM(p)
92# else
93# define SWIGUNUSEDPARM(p) p SWIGUNUSED
94# endif
95#endif
96
97/* internal SWIG method */
98#ifndef SWIGINTERN
99# define SWIGINTERN static SWIGUNUSED
100#endif
101
102/* internal inline SWIG method */
103#ifndef SWIGINTERNINLINE
104# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
105#endif
106
107/* exporting methods */
108#if defined(__GNUC__)
109# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
110# ifndef GCC_HASCLASSVISIBILITY
111# define GCC_HASCLASSVISIBILITY
112# endif
113# endif
114#endif
115
116#ifndef SWIGEXPORT
117# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
118# if defined(STATIC_LINKED)
119# define SWIGEXPORT
120# else
121# define SWIGEXPORT __declspec(dllexport)
122# endif
123# else
124# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
125# define SWIGEXPORT __attribute__ ((visibility("default")))
126# else
127# define SWIGEXPORT
128# endif
129# endif
130#endif
131
132/* calling conventions for Windows */
133#ifndef SWIGSTDCALL
134# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
135# define SWIGSTDCALL __stdcall
136# else
137# define SWIGSTDCALL
138# endif
139#endif
140
141/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
142#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
143# define _CRT_SECURE_NO_DEPRECATE
144#endif
145
146/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
147#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
148# define _SCL_SECURE_NO_DEPRECATE
149#endif
150
151/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
152#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
153# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
154#endif
155
156/* Intel's compiler complains if a variable which was never initialised is
157 * cast to void, which is a common idiom which we use to indicate that we
158 * are aware a variable isn't used. So we just silence that warning.
159 * See: https://github.com/swig/swig/issues/192 for more discussion.
160 */
161#ifdef __INTEL_COMPILER
162# pragma warning disable 592
163#endif
164
165
166#include <stdlib.h>
167#include <string.h>
168#include <stdio.h>
169
170
171/* Support for throwing C# exceptions from C/C++. There are two types:
172 * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
173typedef enum {
174 SWIG_CSharpApplicationException,
175 SWIG_CSharpArithmeticException,
176 SWIG_CSharpDivideByZeroException,
177 SWIG_CSharpIndexOutOfRangeException,
178 SWIG_CSharpInvalidCastException,
179 SWIG_CSharpInvalidOperationException,
180 SWIG_CSharpIOException,
181 SWIG_CSharpNullReferenceException,
182 SWIG_CSharpOutOfMemoryException,
183 SWIG_CSharpOverflowException,
184 SWIG_CSharpSystemException
185} SWIG_CSharpExceptionCodes;
186
187typedef enum {
188 SWIG_CSharpArgumentException,
189 SWIG_CSharpArgumentNullException,
190 SWIG_CSharpArgumentOutOfRangeException
191} SWIG_CSharpExceptionArgumentCodes;
192
193typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
194typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
195
196typedef struct {
197 SWIG_CSharpExceptionCodes code;
198 SWIG_CSharpExceptionCallback_t callback;
199} SWIG_CSharpException_t;
200
201typedef struct {
202 SWIG_CSharpExceptionArgumentCodes code;
203 SWIG_CSharpExceptionArgumentCallback_t callback;
204} SWIG_CSharpExceptionArgument_t;
205
206static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
207 { SWIG_CSharpApplicationException, NULL },
208 { SWIG_CSharpArithmeticException, NULL },
209 { SWIG_CSharpDivideByZeroException, NULL },
210 { SWIG_CSharpIndexOutOfRangeException, NULL },
211 { SWIG_CSharpInvalidCastException, NULL },
212 { SWIG_CSharpInvalidOperationException, NULL },
213 { SWIG_CSharpIOException, NULL },
214 { SWIG_CSharpNullReferenceException, NULL },
215 { SWIG_CSharpOutOfMemoryException, NULL },
216 { SWIG_CSharpOverflowException, NULL },
217 { SWIG_CSharpSystemException, NULL }
218};
219
220static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
221 { SWIG_CSharpArgumentException, NULL },
222 { SWIG_CSharpArgumentNullException, NULL },
223 { SWIG_CSharpArgumentOutOfRangeException, NULL }
224};
225
226static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
227 SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
228 if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
229 callback = SWIG_csharp_exceptions[code].callback;
230 }
231 callback(msg);
232}
233
234static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
235 SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
236 if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
237 callback = SWIG_csharp_exceptions_argument[code].callback;
238 }
239 callback(msg, param_name);
240}
241
242
243#ifdef __cplusplus
244extern "C"
245#endif
246SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_operations_research_linear_solver(
247 SWIG_CSharpExceptionCallback_t applicationCallback,
248 SWIG_CSharpExceptionCallback_t arithmeticCallback,
249 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
250 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
251 SWIG_CSharpExceptionCallback_t invalidCastCallback,
252 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
253 SWIG_CSharpExceptionCallback_t ioCallback,
254 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
255 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
256 SWIG_CSharpExceptionCallback_t overflowCallback,
257 SWIG_CSharpExceptionCallback_t systemCallback) {
258 SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
259 SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
260 SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
261 SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
262 SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
263 SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
264 SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
265 SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
266 SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
267 SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
268 SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
269}
270
271#ifdef __cplusplus
272extern "C"
273#endif
274SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_operations_research_linear_solver(
275 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
276 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
277 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
278 SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
279 SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
280 SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
281}
282
283
284/* Callback for returning strings to C# without leaking memory */
285typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
286static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
287
288
289#ifdef __cplusplus
290extern "C"
291#endif
292SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_operations_research_linear_solver(SWIG_CSharpStringHelperCallback callback) {
293 SWIG_csharp_string_callback = callback;
294}
295
296
297/* Contract support */
298
299#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
300
301
302#include <stdint.h> // Use the C99 official header
303
304
305#include <typeinfo>
306#include <stdexcept>
307
308
309#include <vector>
310#include <algorithm>
311#include <stdexcept>
312
313
314#include <cstdint>
315#include <string>
316#include <vector>
317
318#include "ortools/base/basictypes.h"
319
320
321#include <string>
322
323
324#include <vector>
325#include "ortools/base/integral_types.h"
326
327SWIGINTERN std::vector< int > *new_std_vector_Sl_int_Sg___SWIG_2(int capacity){
328 std::vector< int >* pv = 0;
329 if (capacity >= 0) {
330 pv = new std::vector< int >();
331 pv->reserve(capacity);
332 } else {
333 throw std::out_of_range("capacity");
334 }
335 return pv;
336 }
337SWIGINTERN int std_vector_Sl_int_Sg__getitemcopy(std::vector< int > *self,int index){
338 if (index>=0 && index<(int)self->size())
339 return (*self)[index];
340 else
341 throw std::out_of_range("index");
342 }
343SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg__getitem(std::vector< int > *self,int index){
344 if (index>=0 && index<(int)self->size())
345 return (*self)[index];
346 else
347 throw std::out_of_range("index");
348 }
349SWIGINTERN void std_vector_Sl_int_Sg__setitem(std::vector< int > *self,int index,int const &val){
350 if (index>=0 && index<(int)self->size())
351 (*self)[index] = val;
352 else
353 throw std::out_of_range("index");
354 }
355SWIGINTERN void std_vector_Sl_int_Sg__AddRange(std::vector< int > *self,std::vector< int > const &values){
356 self->insert(self->end(), values.begin(), values.end());
357 }
358SWIGINTERN std::vector< int > *std_vector_Sl_int_Sg__GetRange(std::vector< int > *self,int index,int count){
359 if (index < 0)
360 throw std::out_of_range("index");
361 if (count < 0)
362 throw std::out_of_range("count");
363 if (index >= (int)self->size()+1 || index+count > (int)self->size())
364 throw std::invalid_argument("invalid range");
365 return new std::vector< int >(self->begin()+index, self->begin()+index+count);
366 }
367SWIGINTERN void std_vector_Sl_int_Sg__Insert(std::vector< int > *self,int index,int const &x){
368 if (index>=0 && index<(int)self->size()+1)
369 self->insert(self->begin()+index, x);
370 else
371 throw std::out_of_range("index");
372 }
373SWIGINTERN void std_vector_Sl_int_Sg__InsertRange(std::vector< int > *self,int index,std::vector< int > const &values){
374 if (index>=0 && index<(int)self->size()+1)
375 self->insert(self->begin()+index, values.begin(), values.end());
376 else
377 throw std::out_of_range("index");
378 }
379SWIGINTERN void std_vector_Sl_int_Sg__RemoveAt(std::vector< int > *self,int index){
380 if (index>=0 && index<(int)self->size())
381 self->erase(self->begin() + index);
382 else
383 throw std::out_of_range("index");
384 }
385SWIGINTERN void std_vector_Sl_int_Sg__RemoveRange(std::vector< int > *self,int index,int count){
386 if (index < 0)
387 throw std::out_of_range("index");
388 if (count < 0)
389 throw std::out_of_range("count");
390 if (index >= (int)self->size()+1 || index+count > (int)self->size())
391 throw std::invalid_argument("invalid range");
392 self->erase(self->begin()+index, self->begin()+index+count);
393 }
394SWIGINTERN std::vector< int > *std_vector_Sl_int_Sg__Repeat(int const &value,int count){
395 if (count < 0)
396 throw std::out_of_range("count");
397 return new std::vector< int >(count, value);
398 }
399SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_0(std::vector< int > *self){
400 std::reverse(self->begin(), self->end());
401 }
402SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_1(std::vector< int > *self,int index,int count){
403 if (index < 0)
404 throw std::out_of_range("index");
405 if (count < 0)
406 throw std::out_of_range("count");
407 if (index >= (int)self->size()+1 || index+count > (int)self->size())
408 throw std::invalid_argument("invalid range");
409 std::reverse(self->begin()+index, self->begin()+index+count);
410 }
411SWIGINTERN void std_vector_Sl_int_Sg__SetRange(std::vector< int > *self,int index,std::vector< int > const &values){
412 if (index < 0)
413 throw std::out_of_range("index");
414 if (index+values.size() > self->size())
415 throw std::out_of_range("index");
416 std::copy(values.begin(), values.end(), self->begin()+index);
417 }
418SWIGINTERN bool std_vector_Sl_int_Sg__Contains(std::vector< int > *self,int const &value){
419 return std::find(self->begin(), self->end(), value) != self->end();
420 }
421SWIGINTERN int std_vector_Sl_int_Sg__IndexOf(std::vector< int > *self,int const &value){
422 int index = -1;
423 std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
424 if (it != self->end())
425 index = (int)(it - self->begin());
426 return index;
427 }
428SWIGINTERN int std_vector_Sl_int_Sg__LastIndexOf(std::vector< int > *self,int const &value){
429 int index = -1;
430 std::vector< int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
431 if (rit != self->rend())
432 index = (int)(self->rend() - 1 - rit);
433 return index;
434 }
435SWIGINTERN bool std_vector_Sl_int_Sg__Remove(std::vector< int > *self,int const &value){
436 std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
437 if (it != self->end()) {
438 self->erase(it);
439 return true;
440 }
441 return false;
442 }
443SWIGINTERN std::vector< std::vector< int > > *new_std_vector_Sl_std_vector_Sl_int_Sg__Sg___SWIG_2(int capacity){
444 std::vector< std::vector< int > >* pv = 0;
445 if (capacity >= 0) {
446 pv = new std::vector< std::vector< int > >();
447 pv->reserve(capacity);
448 } else {
449 throw std::out_of_range("capacity");
450 }
451 return pv;
452 }
453SWIGINTERN std::vector< int > std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitemcopy(std::vector< std::vector< int > > *self,int index){
454 if (index>=0 && index<(int)self->size())
455 return (*self)[index];
456 else
457 throw std::out_of_range("index");
458 }
459SWIGINTERN std::vector< std::vector< int > >::value_type const &std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitem(std::vector< std::vector< int > > *self,int index){
460 if (index>=0 && index<(int)self->size())
461 return (*self)[index];
462 else
463 throw std::out_of_range("index");
464 }
465SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__setitem(std::vector< std::vector< int > > *self,int index,std::vector< int > const &val){
466 if (index>=0 && index<(int)self->size())
467 (*self)[index] = val;
468 else
469 throw std::out_of_range("index");
470 }
471SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__AddRange(std::vector< std::vector< int > > *self,std::vector< std::vector< int > > const &values){
472 self->insert(self->end(), values.begin(), values.end());
473 }
474SWIGINTERN std::vector< std::vector< int > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg__GetRange(std::vector< std::vector< int > > *self,int index,int count){
475 if (index < 0)
476 throw std::out_of_range("index");
477 if (count < 0)
478 throw std::out_of_range("count");
479 if (index >= (int)self->size()+1 || index+count > (int)self->size())
480 throw std::invalid_argument("invalid range");
481 return new std::vector< std::vector< int > >(self->begin()+index, self->begin()+index+count);
482 }
483SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Insert(std::vector< std::vector< int > > *self,int index,std::vector< int > const &x){
484 if (index>=0 && index<(int)self->size()+1)
485 self->insert(self->begin()+index, x);
486 else
487 throw std::out_of_range("index");
488 }
489SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__InsertRange(std::vector< std::vector< int > > *self,int index,std::vector< std::vector< int > > const &values){
490 if (index>=0 && index<(int)self->size()+1)
491 self->insert(self->begin()+index, values.begin(), values.end());
492 else
493 throw std::out_of_range("index");
494 }
495SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveAt(std::vector< std::vector< int > > *self,int index){
496 if (index>=0 && index<(int)self->size())
497 self->erase(self->begin() + index);
498 else
499 throw std::out_of_range("index");
500 }
501SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveRange(std::vector< std::vector< int > > *self,int index,int count){
502 if (index < 0)
503 throw std::out_of_range("index");
504 if (count < 0)
505 throw std::out_of_range("count");
506 if (index >= (int)self->size()+1 || index+count > (int)self->size())
507 throw std::invalid_argument("invalid range");
508 self->erase(self->begin()+index, self->begin()+index+count);
509 }
510SWIGINTERN std::vector< std::vector< int > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg__Repeat(std::vector< int > const &value,int count){
511 if (count < 0)
512 throw std::out_of_range("count");
513 return new std::vector< std::vector< int > >(count, value);
514 }
515SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< int > > *self){
516 std::reverse(self->begin(), self->end());
517 }
518SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< int > > *self,int index,int count){
519 if (index < 0)
520 throw std::out_of_range("index");
521 if (count < 0)
522 throw std::out_of_range("count");
523 if (index >= (int)self->size()+1 || index+count > (int)self->size())
524 throw std::invalid_argument("invalid range");
525 std::reverse(self->begin()+index, self->begin()+index+count);
526 }
527SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__SetRange(std::vector< std::vector< int > > *self,int index,std::vector< std::vector< int > > const &values){
528 if (index < 0)
529 throw std::out_of_range("index");
530 if (index+values.size() > self->size())
531 throw std::out_of_range("index");
532 std::copy(values.begin(), values.end(), self->begin()+index);
533 }
534SWIGINTERN std::vector< int64_t > *new_std_vector_Sl_int64_t_Sg___SWIG_2(int capacity){
535 std::vector< long long >* pv = 0;
536 if (capacity >= 0) {
537 pv = new std::vector< long long >();
538 pv->reserve(capacity);
539 } else {
540 throw std::out_of_range("capacity");
541 }
542 return pv;
543 }
544SWIGINTERN long long std_vector_Sl_int64_t_Sg__getitemcopy(std::vector< int64_t > *self,int index){
545 if (index>=0 && index<(int)self->size())
546 return (*self)[index];
547 else
548 throw std::out_of_range("index");
549 }
550SWIGINTERN std::vector< long long >::value_type const &std_vector_Sl_int64_t_Sg__getitem(std::vector< int64_t > *self,int index){
551 if (index>=0 && index<(int)self->size())
552 return (*self)[index];
553 else
554 throw std::out_of_range("index");
555 }
556SWIGINTERN void std_vector_Sl_int64_t_Sg__setitem(std::vector< int64_t > *self,int index,long long const &val){
557 if (index>=0 && index<(int)self->size())
558 (*self)[index] = val;
559 else
560 throw std::out_of_range("index");
561 }
562SWIGINTERN void std_vector_Sl_int64_t_Sg__AddRange(std::vector< int64_t > *self,std::vector< long long > const &values){
563 self->insert(self->end(), values.begin(), values.end());
564 }
565SWIGINTERN std::vector< long long > *std_vector_Sl_int64_t_Sg__GetRange(std::vector< int64_t > *self,int index,int count){
566 if (index < 0)
567 throw std::out_of_range("index");
568 if (count < 0)
569 throw std::out_of_range("count");
570 if (index >= (int)self->size()+1 || index+count > (int)self->size())
571 throw std::invalid_argument("invalid range");
572 return new std::vector< long long >(self->begin()+index, self->begin()+index+count);
573 }
574SWIGINTERN void std_vector_Sl_int64_t_Sg__Insert(std::vector< int64_t > *self,int index,long long const &x){
575 if (index>=0 && index<(int)self->size()+1)
576 self->insert(self->begin()+index, x);
577 else
578 throw std::out_of_range("index");
579 }
580SWIGINTERN void std_vector_Sl_int64_t_Sg__InsertRange(std::vector< int64_t > *self,int index,std::vector< long long > const &values){
581 if (index>=0 && index<(int)self->size()+1)
582 self->insert(self->begin()+index, values.begin(), values.end());
583 else
584 throw std::out_of_range("index");
585 }
586SWIGINTERN void std_vector_Sl_int64_t_Sg__RemoveAt(std::vector< int64_t > *self,int index){
587 if (index>=0 && index<(int)self->size())
588 self->erase(self->begin() + index);
589 else
590 throw std::out_of_range("index");
591 }
592SWIGINTERN void std_vector_Sl_int64_t_Sg__RemoveRange(std::vector< int64_t > *self,int index,int count){
593 if (index < 0)
594 throw std::out_of_range("index");
595 if (count < 0)
596 throw std::out_of_range("count");
597 if (index >= (int)self->size()+1 || index+count > (int)self->size())
598 throw std::invalid_argument("invalid range");
599 self->erase(self->begin()+index, self->begin()+index+count);
600 }
601SWIGINTERN std::vector< long long > *std_vector_Sl_int64_t_Sg__Repeat(long long const &value,int count){
602 if (count < 0)
603 throw std::out_of_range("count");
604 return new std::vector< long long >(count, value);
605 }
606SWIGINTERN void std_vector_Sl_int64_t_Sg__Reverse__SWIG_0(std::vector< int64_t > *self){
607 std::reverse(self->begin(), self->end());
608 }
609SWIGINTERN void std_vector_Sl_int64_t_Sg__Reverse__SWIG_1(std::vector< int64_t > *self,int index,int count){
610 if (index < 0)
611 throw std::out_of_range("index");
612 if (count < 0)
613 throw std::out_of_range("count");
614 if (index >= (int)self->size()+1 || index+count > (int)self->size())
615 throw std::invalid_argument("invalid range");
616 std::reverse(self->begin()+index, self->begin()+index+count);
617 }
618SWIGINTERN void std_vector_Sl_int64_t_Sg__SetRange(std::vector< int64_t > *self,int index,std::vector< long long > const &values){
619 if (index < 0)
620 throw std::out_of_range("index");
621 if (index+values.size() > self->size())
622 throw std::out_of_range("index");
623 std::copy(values.begin(), values.end(), self->begin()+index);
624 }
625SWIGINTERN bool std_vector_Sl_int64_t_Sg__Contains(std::vector< int64_t > *self,long long const &value){
626 return std::find(self->begin(), self->end(), value) != self->end();
627 }
628SWIGINTERN int std_vector_Sl_int64_t_Sg__IndexOf(std::vector< int64_t > *self,long long const &value){
629 int index = -1;
630 std::vector< long long >::iterator it = std::find(self->begin(), self->end(), value);
631 if (it != self->end())
632 index = (int)(it - self->begin());
633 return index;
634 }
635SWIGINTERN int std_vector_Sl_int64_t_Sg__LastIndexOf(std::vector< int64_t > *self,long long const &value){
636 int index = -1;
637 std::vector< long long >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
638 if (rit != self->rend())
639 index = (int)(self->rend() - 1 - rit);
640 return index;
641 }
642SWIGINTERN bool std_vector_Sl_int64_t_Sg__Remove(std::vector< int64_t > *self,long long const &value){
643 std::vector< long long >::iterator it = std::find(self->begin(), self->end(), value);
644 if (it != self->end()) {
645 self->erase(it);
646 return true;
647 }
648 return false;
649 }
650SWIGINTERN std::vector< std::vector< int64_t > > *new_std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg___SWIG_2(int capacity){
651 std::vector< std::vector< int64_t > >* pv = 0;
652 if (capacity >= 0) {
653 pv = new std::vector< std::vector< int64_t > >();
654 pv->reserve(capacity);
655 } else {
656 throw std::out_of_range("capacity");
657 }
658 return pv;
659 }
660SWIGINTERN std::vector< int64_t > std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitemcopy(std::vector< std::vector< int64_t > > *self,int index){
661 if (index>=0 && index<(int)self->size())
662 return (*self)[index];
663 else
664 throw std::out_of_range("index");
665 }
666SWIGINTERN std::vector< std::vector< long long > >::value_type const &std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitem(std::vector< std::vector< int64_t > > *self,int index){
667 if (index>=0 && index<(int)self->size())
668 return (*self)[index];
669 else
670 throw std::out_of_range("index");
671 }
672SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__setitem(std::vector< std::vector< int64_t > > *self,int index,std::vector< int64_t > const &val){
673 if (index>=0 && index<(int)self->size())
674 (*self)[index] = val;
675 else
676 throw std::out_of_range("index");
677 }
678SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__AddRange(std::vector< std::vector< int64_t > > *self,std::vector< std::vector< int64_t > > const &values){
679 self->insert(self->end(), values.begin(), values.end());
680 }
681SWIGINTERN std::vector< std::vector< int64_t > > *std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__GetRange(std::vector< std::vector< int64_t > > *self,int index,int count){
682 if (index < 0)
683 throw std::out_of_range("index");
684 if (count < 0)
685 throw std::out_of_range("count");
686 if (index >= (int)self->size()+1 || index+count > (int)self->size())
687 throw std::invalid_argument("invalid range");
688 return new std::vector< std::vector< int64_t > >(self->begin()+index, self->begin()+index+count);
689 }
690SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Insert(std::vector< std::vector< int64_t > > *self,int index,std::vector< int64_t > const &x){
691 if (index>=0 && index<(int)self->size()+1)
692 self->insert(self->begin()+index, x);
693 else
694 throw std::out_of_range("index");
695 }
696SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__InsertRange(std::vector< std::vector< int64_t > > *self,int index,std::vector< std::vector< int64_t > > const &values){
697 if (index>=0 && index<(int)self->size()+1)
698 self->insert(self->begin()+index, values.begin(), values.end());
699 else
700 throw std::out_of_range("index");
701 }
702SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveAt(std::vector< std::vector< int64_t > > *self,int index){
703 if (index>=0 && index<(int)self->size())
704 self->erase(self->begin() + index);
705 else
706 throw std::out_of_range("index");
707 }
708SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveRange(std::vector< std::vector< int64_t > > *self,int index,int count){
709 if (index < 0)
710 throw std::out_of_range("index");
711 if (count < 0)
712 throw std::out_of_range("count");
713 if (index >= (int)self->size()+1 || index+count > (int)self->size())
714 throw std::invalid_argument("invalid range");
715 self->erase(self->begin()+index, self->begin()+index+count);
716 }
717SWIGINTERN std::vector< std::vector< int64_t > > *std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Repeat(std::vector< int64_t > const &value,int count){
718 if (count < 0)
719 throw std::out_of_range("count");
720 return new std::vector< std::vector< int64_t > >(count, value);
721 }
722SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< int64_t > > *self){
723 std::reverse(self->begin(), self->end());
724 }
725SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< int64_t > > *self,int index,int count){
726 if (index < 0)
727 throw std::out_of_range("index");
728 if (count < 0)
729 throw std::out_of_range("count");
730 if (index >= (int)self->size()+1 || index+count > (int)self->size())
731 throw std::invalid_argument("invalid range");
732 std::reverse(self->begin()+index, self->begin()+index+count);
733 }
734SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__SetRange(std::vector< std::vector< int64_t > > *self,int index,std::vector< std::vector< int64_t > > const &values){
735 if (index < 0)
736 throw std::out_of_range("index");
737 if (index+values.size() > self->size())
738 throw std::out_of_range("index");
739 std::copy(values.begin(), values.end(), self->begin()+index);
740 }
741
742#include "ortools/linear_solver/linear_solver.h"
743#include "ortools/linear_solver/linear_solver.pb.h"
744#include "ortools/linear_solver/model_exporter.h"
745
746SWIGINTERN std::vector< double > *new_std_vector_Sl_double_Sg___SWIG_2(int capacity){
747 std::vector< double >* pv = 0;
748 if (capacity >= 0) {
749 pv = new std::vector< double >();
750 pv->reserve(capacity);
751 } else {
752 throw std::out_of_range("capacity");
753 }
754 return pv;
755 }
756SWIGINTERN double std_vector_Sl_double_Sg__getitemcopy(std::vector< double > *self,int index){
757 if (index>=0 && index<(int)self->size())
758 return (*self)[index];
759 else
760 throw std::out_of_range("index");
761 }
762SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg__getitem(std::vector< double > *self,int index){
763 if (index>=0 && index<(int)self->size())
764 return (*self)[index];
765 else
766 throw std::out_of_range("index");
767 }
768SWIGINTERN void std_vector_Sl_double_Sg__setitem(std::vector< double > *self,int index,double const &val){
769 if (index>=0 && index<(int)self->size())
770 (*self)[index] = val;
771 else
772 throw std::out_of_range("index");
773 }
774SWIGINTERN void std_vector_Sl_double_Sg__AddRange(std::vector< double > *self,std::vector< double > const &values){
775 self->insert(self->end(), values.begin(), values.end());
776 }
777SWIGINTERN std::vector< double > *std_vector_Sl_double_Sg__GetRange(std::vector< double > *self,int index,int count){
778 if (index < 0)
779 throw std::out_of_range("index");
780 if (count < 0)
781 throw std::out_of_range("count");
782 if (index >= (int)self->size()+1 || index+count > (int)self->size())
783 throw std::invalid_argument("invalid range");
784 return new std::vector< double >(self->begin()+index, self->begin()+index+count);
785 }
786SWIGINTERN void std_vector_Sl_double_Sg__Insert(std::vector< double > *self,int index,double const &x){
787 if (index>=0 && index<(int)self->size()+1)
788 self->insert(self->begin()+index, x);
789 else
790 throw std::out_of_range("index");
791 }
792SWIGINTERN void std_vector_Sl_double_Sg__InsertRange(std::vector< double > *self,int index,std::vector< double > const &values){
793 if (index>=0 && index<(int)self->size()+1)
794 self->insert(self->begin()+index, values.begin(), values.end());
795 else
796 throw std::out_of_range("index");
797 }
798SWIGINTERN void std_vector_Sl_double_Sg__RemoveAt(std::vector< double > *self,int index){
799 if (index>=0 && index<(int)self->size())
800 self->erase(self->begin() + index);
801 else
802 throw std::out_of_range("index");
803 }
804SWIGINTERN void std_vector_Sl_double_Sg__RemoveRange(std::vector< double > *self,int index,int count){
805 if (index < 0)
806 throw std::out_of_range("index");
807 if (count < 0)
808 throw std::out_of_range("count");
809 if (index >= (int)self->size()+1 || index+count > (int)self->size())
810 throw std::invalid_argument("invalid range");
811 self->erase(self->begin()+index, self->begin()+index+count);
812 }
813SWIGINTERN std::vector< double > *std_vector_Sl_double_Sg__Repeat(double const &value,int count){
814 if (count < 0)
815 throw std::out_of_range("count");
816 return new std::vector< double >(count, value);
817 }
818SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_0(std::vector< double > *self){
819 std::reverse(self->begin(), self->end());
820 }
821SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_1(std::vector< double > *self,int index,int count){
822 if (index < 0)
823 throw std::out_of_range("index");
824 if (count < 0)
825 throw std::out_of_range("count");
826 if (index >= (int)self->size()+1 || index+count > (int)self->size())
827 throw std::invalid_argument("invalid range");
828 std::reverse(self->begin()+index, self->begin()+index+count);
829 }
830SWIGINTERN void std_vector_Sl_double_Sg__SetRange(std::vector< double > *self,int index,std::vector< double > const &values){
831 if (index < 0)
832 throw std::out_of_range("index");
833 if (index+values.size() > self->size())
834 throw std::out_of_range("index");
835 std::copy(values.begin(), values.end(), self->begin()+index);
836 }
837SWIGINTERN bool std_vector_Sl_double_Sg__Contains(std::vector< double > *self,double const &value){
838 return std::find(self->begin(), self->end(), value) != self->end();
839 }
840SWIGINTERN int std_vector_Sl_double_Sg__IndexOf(std::vector< double > *self,double const &value){
841 int index = -1;
842 std::vector< double >::iterator it = std::find(self->begin(), self->end(), value);
843 if (it != self->end())
844 index = (int)(it - self->begin());
845 return index;
846 }
847SWIGINTERN int std_vector_Sl_double_Sg__LastIndexOf(std::vector< double > *self,double const &value){
848 int index = -1;
849 std::vector< double >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
850 if (rit != self->rend())
851 index = (int)(self->rend() - 1 - rit);
852 return index;
853 }
854SWIGINTERN bool std_vector_Sl_double_Sg__Remove(std::vector< double > *self,double const &value){
855 std::vector< double >::iterator it = std::find(self->begin(), self->end(), value);
856 if (it != self->end()) {
857 self->erase(it);
858 return true;
859 }
860 return false;
861 }
862SWIGINTERN std::vector< operations_research::MPConstraint * > *new_std_vector_Sl_operations_research_MPConstraint_Sm__Sg___SWIG_2(int capacity){
863 std::vector< operations_research::MPConstraint* >* pv = 0;
864 if (capacity >= 0) {
865 pv = new std::vector< operations_research::MPConstraint* >();
866 pv->reserve(capacity);
867 } else {
868 throw std::out_of_range("capacity");
869 }
870 return pv;
871 }
872SWIGINTERN operations_research::MPConstraint *std_vector_Sl_operations_research_MPConstraint_Sm__Sg__getitemcopy(std::vector< operations_research::MPConstraint * > *self,int index){
873 if (index>=0 && index<(int)self->size())
874 return (*self)[index];
875 else
876 throw std::out_of_range("index");
877 }
878SWIGINTERN std::vector< operations_research::MPConstraint * >::value_type const &std_vector_Sl_operations_research_MPConstraint_Sm__Sg__getitem(std::vector< operations_research::MPConstraint * > *self,int index){
879 if (index>=0 && index<(int)self->size())
880 return (*self)[index];
881 else
882 throw std::out_of_range("index");
883 }
884SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__setitem(std::vector< operations_research::MPConstraint * > *self,int index,operations_research::MPConstraint *const &val){
885 if (index>=0 && index<(int)self->size())
886 (*self)[index] = val;
887 else
888 throw std::out_of_range("index");
889 }
890SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__AddRange(std::vector< operations_research::MPConstraint * > *self,std::vector< operations_research::MPConstraint * > const &values){
891 self->insert(self->end(), values.begin(), values.end());
892 }
893SWIGINTERN std::vector< operations_research::MPConstraint * > *std_vector_Sl_operations_research_MPConstraint_Sm__Sg__GetRange(std::vector< operations_research::MPConstraint * > *self,int index,int count){
894 if (index < 0)
895 throw std::out_of_range("index");
896 if (count < 0)
897 throw std::out_of_range("count");
898 if (index >= (int)self->size()+1 || index+count > (int)self->size())
899 throw std::invalid_argument("invalid range");
900 return new std::vector< operations_research::MPConstraint* >(self->begin()+index, self->begin()+index+count);
901 }
902SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Insert(std::vector< operations_research::MPConstraint * > *self,int index,operations_research::MPConstraint *const &x){
903 if (index>=0 && index<(int)self->size()+1)
904 self->insert(self->begin()+index, x);
905 else
906 throw std::out_of_range("index");
907 }
908SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__InsertRange(std::vector< operations_research::MPConstraint * > *self,int index,std::vector< operations_research::MPConstraint * > const &values){
909 if (index>=0 && index<(int)self->size()+1)
910 self->insert(self->begin()+index, values.begin(), values.end());
911 else
912 throw std::out_of_range("index");
913 }
914SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__RemoveAt(std::vector< operations_research::MPConstraint * > *self,int index){
915 if (index>=0 && index<(int)self->size())
916 self->erase(self->begin() + index);
917 else
918 throw std::out_of_range("index");
919 }
920SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__RemoveRange(std::vector< operations_research::MPConstraint * > *self,int index,int count){
921 if (index < 0)
922 throw std::out_of_range("index");
923 if (count < 0)
924 throw std::out_of_range("count");
925 if (index >= (int)self->size()+1 || index+count > (int)self->size())
926 throw std::invalid_argument("invalid range");
927 self->erase(self->begin()+index, self->begin()+index+count);
928 }
929SWIGINTERN std::vector< operations_research::MPConstraint * > *std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Repeat(operations_research::MPConstraint *const &value,int count){
930 if (count < 0)
931 throw std::out_of_range("count");
932 return new std::vector< operations_research::MPConstraint* >(count, value);
933 }
934SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::MPConstraint * > *self){
935 std::reverse(self->begin(), self->end());
936 }
937SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::MPConstraint * > *self,int index,int count){
938 if (index < 0)
939 throw std::out_of_range("index");
940 if (count < 0)
941 throw std::out_of_range("count");
942 if (index >= (int)self->size()+1 || index+count > (int)self->size())
943 throw std::invalid_argument("invalid range");
944 std::reverse(self->begin()+index, self->begin()+index+count);
945 }
946SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__SetRange(std::vector< operations_research::MPConstraint * > *self,int index,std::vector< operations_research::MPConstraint * > const &values){
947 if (index < 0)
948 throw std::out_of_range("index");
949 if (index+values.size() > self->size())
950 throw std::out_of_range("index");
951 std::copy(values.begin(), values.end(), self->begin()+index);
952 }
953SWIGINTERN bool std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Contains(std::vector< operations_research::MPConstraint * > *self,operations_research::MPConstraint *const &value){
954 return std::find(self->begin(), self->end(), value) != self->end();
955 }
956SWIGINTERN int std_vector_Sl_operations_research_MPConstraint_Sm__Sg__IndexOf(std::vector< operations_research::MPConstraint * > *self,operations_research::MPConstraint *const &value){
957 int index = -1;
958 std::vector< operations_research::MPConstraint* >::iterator it = std::find(self->begin(), self->end(), value);
959 if (it != self->end())
960 index = (int)(it - self->begin());
961 return index;
962 }
963SWIGINTERN int std_vector_Sl_operations_research_MPConstraint_Sm__Sg__LastIndexOf(std::vector< operations_research::MPConstraint * > *self,operations_research::MPConstraint *const &value){
964 int index = -1;
965 std::vector< operations_research::MPConstraint* >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
966 if (rit != self->rend())
967 index = (int)(self->rend() - 1 - rit);
968 return index;
969 }
970SWIGINTERN bool std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Remove(std::vector< operations_research::MPConstraint * > *self,operations_research::MPConstraint *const &value){
971 std::vector< operations_research::MPConstraint* >::iterator it = std::find(self->begin(), self->end(), value);
972 if (it != self->end()) {
973 self->erase(it);
974 return true;
975 }
976 return false;
977 }
978SWIGINTERN std::vector< operations_research::MPVariable * > *new_std_vector_Sl_operations_research_MPVariable_Sm__Sg___SWIG_2(int capacity){
979 std::vector< operations_research::MPVariable* >* pv = 0;
980 if (capacity >= 0) {
981 pv = new std::vector< operations_research::MPVariable* >();
982 pv->reserve(capacity);
983 } else {
984 throw std::out_of_range("capacity");
985 }
986 return pv;
987 }
988SWIGINTERN operations_research::MPVariable *std_vector_Sl_operations_research_MPVariable_Sm__Sg__getitemcopy(std::vector< operations_research::MPVariable * > *self,int index){
989 if (index>=0 && index<(int)self->size())
990 return (*self)[index];
991 else
992 throw std::out_of_range("index");
993 }
994SWIGINTERN std::vector< operations_research::MPVariable * >::value_type const &std_vector_Sl_operations_research_MPVariable_Sm__Sg__getitem(std::vector< operations_research::MPVariable * > *self,int index){
995 if (index>=0 && index<(int)self->size())
996 return (*self)[index];
997 else
998 throw std::out_of_range("index");
999 }
1000SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__setitem(std::vector< operations_research::MPVariable * > *self,int index,operations_research::MPVariable *const &val){
1001 if (index>=0 && index<(int)self->size())
1002 (*self)[index] = val;
1003 else
1004 throw std::out_of_range("index");
1005 }
1006SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__AddRange(std::vector< operations_research::MPVariable * > *self,std::vector< operations_research::MPVariable * > const &values){
1007 self->insert(self->end(), values.begin(), values.end());
1008 }
1009SWIGINTERN std::vector< operations_research::MPVariable * > *std_vector_Sl_operations_research_MPVariable_Sm__Sg__GetRange(std::vector< operations_research::MPVariable * > *self,int index,int count){
1010 if (index < 0)
1011 throw std::out_of_range("index");
1012 if (count < 0)
1013 throw std::out_of_range("count");
1014 if (index >= (int)self->size()+1 || index+count > (int)self->size())
1015 throw std::invalid_argument("invalid range");
1016 return new std::vector< operations_research::MPVariable* >(self->begin()+index, self->begin()+index+count);
1017 }
1018SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__Insert(std::vector< operations_research::MPVariable * > *self,int index,operations_research::MPVariable *const &x){
1019 if (index>=0 && index<(int)self->size()+1)
1020 self->insert(self->begin()+index, x);
1021 else
1022 throw std::out_of_range("index");
1023 }
1024SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__InsertRange(std::vector< operations_research::MPVariable * > *self,int index,std::vector< operations_research::MPVariable * > const &values){
1025 if (index>=0 && index<(int)self->size()+1)
1026 self->insert(self->begin()+index, values.begin(), values.end());
1027 else
1028 throw std::out_of_range("index");
1029 }
1030SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__RemoveAt(std::vector< operations_research::MPVariable * > *self,int index){
1031 if (index>=0 && index<(int)self->size())
1032 self->erase(self->begin() + index);
1033 else
1034 throw std::out_of_range("index");
1035 }
1036SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__RemoveRange(std::vector< operations_research::MPVariable * > *self,int index,int count){
1037 if (index < 0)
1038 throw std::out_of_range("index");
1039 if (count < 0)
1040 throw std::out_of_range("count");
1041 if (index >= (int)self->size()+1 || index+count > (int)self->size())
1042 throw std::invalid_argument("invalid range");
1043 self->erase(self->begin()+index, self->begin()+index+count);
1044 }
1045SWIGINTERN std::vector< operations_research::MPVariable * > *std_vector_Sl_operations_research_MPVariable_Sm__Sg__Repeat(operations_research::MPVariable *const &value,int count){
1046 if (count < 0)
1047 throw std::out_of_range("count");
1048 return new std::vector< operations_research::MPVariable* >(count, value);
1049 }
1050SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::MPVariable * > *self){
1051 std::reverse(self->begin(), self->end());
1052 }
1053SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::MPVariable * > *self,int index,int count){
1054 if (index < 0)
1055 throw std::out_of_range("index");
1056 if (count < 0)
1057 throw std::out_of_range("count");
1058 if (index >= (int)self->size()+1 || index+count > (int)self->size())
1059 throw std::invalid_argument("invalid range");
1060 std::reverse(self->begin()+index, self->begin()+index+count);
1061 }
1062SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__SetRange(std::vector< operations_research::MPVariable * > *self,int index,std::vector< operations_research::MPVariable * > const &values){
1063 if (index < 0)
1064 throw std::out_of_range("index");
1065 if (index+values.size() > self->size())
1066 throw std::out_of_range("index");
1067 std::copy(values.begin(), values.end(), self->begin()+index);
1068 }
1069SWIGINTERN bool std_vector_Sl_operations_research_MPVariable_Sm__Sg__Contains(std::vector< operations_research::MPVariable * > *self,operations_research::MPVariable *const &value){
1070 return std::find(self->begin(), self->end(), value) != self->end();
1071 }
1072SWIGINTERN int std_vector_Sl_operations_research_MPVariable_Sm__Sg__IndexOf(std::vector< operations_research::MPVariable * > *self,operations_research::MPVariable *const &value){
1073 int index = -1;
1074 std::vector< operations_research::MPVariable* >::iterator it = std::find(self->begin(), self->end(), value);
1075 if (it != self->end())
1076 index = (int)(it - self->begin());
1077 return index;
1078 }
1079SWIGINTERN int std_vector_Sl_operations_research_MPVariable_Sm__Sg__LastIndexOf(std::vector< operations_research::MPVariable * > *self,operations_research::MPVariable *const &value){
1080 int index = -1;
1081 std::vector< operations_research::MPVariable* >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1082 if (rit != self->rend())
1083 index = (int)(self->rend() - 1 - rit);
1084 return index;
1085 }
1086SWIGINTERN bool std_vector_Sl_operations_research_MPVariable_Sm__Sg__Remove(std::vector< operations_research::MPVariable * > *self,operations_research::MPVariable *const &value){
1087 std::vector< operations_research::MPVariable* >::iterator it = std::find(self->begin(), self->end(), value);
1088 if (it != self->end()) {
1089 self->erase(it);
1090 return true;
1091 }
1092 return false;
1093 }
1094SWIGINTERN std::string operations_research_MPSolver_ExportModelAsLpFormat(operations_research::MPSolver *self,bool obfuscated){
1095 operations_research::MPModelExportOptions options;
1096 options.obfuscate = obfuscated;
1097 operations_research::MPModelProto model;
1098 self->ExportModelToProto(&model);
1099 return ExportModelAsLpFormat(model, options).value_or("");
1100 }
1101SWIGINTERN std::string operations_research_MPSolver_ExportModelAsMpsFormat(operations_research::MPSolver *self,bool fixed_format,bool obfuscated){
1102 operations_research::MPModelExportOptions options;
1103 options.obfuscate = obfuscated;
1104 operations_research::MPModelProto model;
1105 self->ExportModelToProto(&model);
1106 return ExportModelAsMpsFormat(model, options).value_or("");
1107 }
1108SWIGINTERN void operations_research_MPSolver_SetHint(operations_research::MPSolver *self,std::vector< operations_research::MPVariable * > const &variables,std::vector< double > const &values){
1109 if (variables.size() != values.size()) {
1110 LOG(FATAL) << "Different number of variables and values when setting "
1111 << "hint.";
1112 }
1113 std::vector<std::pair<const operations_research::MPVariable*, double> >
1114 hint(variables.size());
1115 for (int i = 0; i < variables.size(); ++i) {
1116 hint[i] = std::make_pair(variables[i], values[i]);
1117 }
1118 self->SetHint(hint);
1119 }
1120SWIGINTERN bool operations_research_MPSolver_SetNumThreads(operations_research::MPSolver *self,int num_theads){
1121 return self->SetNumThreads(num_theads).ok();
1122 }
1123
1124#ifdef __cplusplus
1125extern "C" {
1126#endif
1127
1128SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Clear___(void * jarg1) {
1129 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1130
1131 arg1 = (std::vector< int > *)jarg1;
1132 (arg1)->clear();
1133}
1134
1135
1136SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Add___(void * jarg1, int jarg2) {
1137 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1138 int *arg2 = 0 ;
1139 int temp2 ;
1140
1141 arg1 = (std::vector< int > *)jarg1;
1142 temp2 = (int)jarg2;
1143 arg2 = &temp2;
1144 (arg1)->push_back((int const &)*arg2);
1145}
1146
1147
1148SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_size___(void * jarg1) {
1149 unsigned long jresult ;
1150 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1151 std::vector< int >::size_type result;
1152
1153 arg1 = (std::vector< int > *)jarg1;
1154 result = ((std::vector< int > const *)arg1)->size();
1155 jresult = (unsigned long)result;
1156 return jresult;
1157}
1158
1159
1160SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_capacity___(void * jarg1) {
1161 unsigned long jresult ;
1162 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1163 std::vector< int >::size_type result;
1164
1165 arg1 = (std::vector< int > *)jarg1;
1166 result = ((std::vector< int > const *)arg1)->capacity();
1167 jresult = (unsigned long)result;
1168 return jresult;
1169}
1170
1171
1172SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_reserve___(void * jarg1, unsigned long jarg2) {
1173 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1174 std::vector< int >::size_type arg2 ;
1175
1176 arg1 = (std::vector< int > *)jarg1;
1177 arg2 = (std::vector< int >::size_type)jarg2;
1178 (arg1)->reserve(arg2);
1179}
1180
1181
1182SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVector__SWIG_0___() {
1183 void * jresult ;
1184 std::vector< int > *result = 0 ;
1185
1186 result = (std::vector< int > *)new std::vector< int >();
1187 jresult = (void *)result;
1188 return jresult;
1189}
1190
1191
1192SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVector__SWIG_1___(void * jarg1) {
1193 void * jresult ;
1194 std::vector< int > *arg1 = 0 ;
1195 std::vector< int > *result = 0 ;
1196
1197 arg1 = (std::vector< int > *)jarg1;
1198 if (!arg1) {
1199 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
1200 return 0;
1201 }
1202 result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
1203 jresult = (void *)result;
1204 return jresult;
1205}
1206
1207
1208SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVector__SWIG_2___(int jarg1) {
1209 void * jresult ;
1210 int arg1 ;
1211 std::vector< int > *result = 0 ;
1212
1213 arg1 = (int)jarg1;
1214 try {
1215 result = (std::vector< int > *)new_std_vector_Sl_int_Sg___SWIG_2(arg1);
1216 } catch(std::out_of_range &_e) {
1217 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1218 return 0;
1219 }
1220 jresult = (void *)result;
1221 return jresult;
1222}
1223
1224
1225SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_getitemcopy___(void * jarg1, int jarg2) {
1226 int jresult ;
1227 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1228 int arg2 ;
1229 int result;
1230
1231 arg1 = (std::vector< int > *)jarg1;
1232 arg2 = (int)jarg2;
1233 try {
1234 result = (int)std_vector_Sl_int_Sg__getitemcopy(arg1,arg2);
1235 } catch(std::out_of_range &_e) {
1236 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1237 return 0;
1238 }
1239 jresult = result;
1240 return jresult;
1241}
1242
1243
1244SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_getitem___(void * jarg1, int jarg2) {
1245 int jresult ;
1246 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1247 int arg2 ;
1248 std::vector< int >::value_type *result = 0 ;
1249
1250 arg1 = (std::vector< int > *)jarg1;
1251 arg2 = (int)jarg2;
1252 try {
1253 result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__getitem(arg1,arg2);
1254 } catch(std::out_of_range &_e) {
1255 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1256 return 0;
1257 }
1258 jresult = *result;
1259 return jresult;
1260}
1261
1262
1263SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_setitem___(void * jarg1, int jarg2, int jarg3) {
1264 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1265 int arg2 ;
1266 int *arg3 = 0 ;
1267 int temp3 ;
1268
1269 arg1 = (std::vector< int > *)jarg1;
1270 arg2 = (int)jarg2;
1271 temp3 = (int)jarg3;
1272 arg3 = &temp3;
1273 try {
1274 std_vector_Sl_int_Sg__setitem(arg1,arg2,(int const &)*arg3);
1275 } catch(std::out_of_range &_e) {
1276 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1277 return ;
1278 }
1279}
1280
1281
1282SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_AddRange___(void * jarg1, void * jarg2) {
1283 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1284 std::vector< int > *arg2 = 0 ;
1285
1286 arg1 = (std::vector< int > *)jarg1;
1287 arg2 = (std::vector< int > *)jarg2;
1288 if (!arg2) {
1289 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
1290 return ;
1291 }
1292 std_vector_Sl_int_Sg__AddRange(arg1,(std::vector< int > const &)*arg2);
1293}
1294
1295
1296SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
1297 void * jresult ;
1298 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1299 int arg2 ;
1300 int arg3 ;
1301 std::vector< int > *result = 0 ;
1302
1303 arg1 = (std::vector< int > *)jarg1;
1304 arg2 = (int)jarg2;
1305 arg3 = (int)jarg3;
1306 try {
1307 result = (std::vector< int > *)std_vector_Sl_int_Sg__GetRange(arg1,arg2,arg3);
1308 } catch(std::out_of_range &_e) {
1309 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1310 return 0;
1311 } catch(std::invalid_argument &_e) {
1312 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
1313 return 0;
1314 }
1315 jresult = (void *)result;
1316 return jresult;
1317}
1318
1319
1320SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Insert___(void * jarg1, int jarg2, int jarg3) {
1321 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1322 int arg2 ;
1323 int *arg3 = 0 ;
1324 int temp3 ;
1325
1326 arg1 = (std::vector< int > *)jarg1;
1327 arg2 = (int)jarg2;
1328 temp3 = (int)jarg3;
1329 arg3 = &temp3;
1330 try {
1331 std_vector_Sl_int_Sg__Insert(arg1,arg2,(int const &)*arg3);
1332 } catch(std::out_of_range &_e) {
1333 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1334 return ;
1335 }
1336}
1337
1338
1339SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
1340 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1341 int arg2 ;
1342 std::vector< int > *arg3 = 0 ;
1343
1344 arg1 = (std::vector< int > *)jarg1;
1345 arg2 = (int)jarg2;
1346 arg3 = (std::vector< int > *)jarg3;
1347 if (!arg3) {
1348 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
1349 return ;
1350 }
1351 try {
1352 std_vector_Sl_int_Sg__InsertRange(arg1,arg2,(std::vector< int > const &)*arg3);
1353 } catch(std::out_of_range &_e) {
1354 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1355 return ;
1356 }
1357}
1358
1359
1360SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_RemoveAt___(void * jarg1, int jarg2) {
1361 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1362 int arg2 ;
1363
1364 arg1 = (std::vector< int > *)jarg1;
1365 arg2 = (int)jarg2;
1366 try {
1367 std_vector_Sl_int_Sg__RemoveAt(arg1,arg2);
1368 } catch(std::out_of_range &_e) {
1369 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1370 return ;
1371 }
1372}
1373
1374
1375SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
1376 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1377 int arg2 ;
1378 int arg3 ;
1379
1380 arg1 = (std::vector< int > *)jarg1;
1381 arg2 = (int)jarg2;
1382 arg3 = (int)jarg3;
1383 try {
1384 std_vector_Sl_int_Sg__RemoveRange(arg1,arg2,arg3);
1385 } catch(std::out_of_range &_e) {
1386 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1387 return ;
1388 } catch(std::invalid_argument &_e) {
1389 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
1390 return ;
1391 }
1392}
1393
1394
1395SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Repeat___(int jarg1, int jarg2) {
1396 void * jresult ;
1397 int *arg1 = 0 ;
1398 int arg2 ;
1399 int temp1 ;
1400 std::vector< int > *result = 0 ;
1401
1402 temp1 = (int)jarg1;
1403 arg1 = &temp1;
1404 arg2 = (int)jarg2;
1405 try {
1406 result = (std::vector< int > *)std_vector_Sl_int_Sg__Repeat((int const &)*arg1,arg2);
1407 } catch(std::out_of_range &_e) {
1408 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1409 return 0;
1410 }
1411 jresult = (void *)result;
1412 return jresult;
1413}
1414
1415
1416SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Reverse__SWIG_0___(void * jarg1) {
1417 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1418
1419 arg1 = (std::vector< int > *)jarg1;
1420 std_vector_Sl_int_Sg__Reverse__SWIG_0(arg1);
1421}
1422
1423
1424SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
1425 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1426 int arg2 ;
1427 int arg3 ;
1428
1429 arg1 = (std::vector< int > *)jarg1;
1430 arg2 = (int)jarg2;
1431 arg3 = (int)jarg3;
1432 try {
1433 std_vector_Sl_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
1434 } catch(std::out_of_range &_e) {
1435 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1436 return ;
1437 } catch(std::invalid_argument &_e) {
1438 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
1439 return ;
1440 }
1441}
1442
1443
1444SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
1445 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1446 int arg2 ;
1447 std::vector< int > *arg3 = 0 ;
1448
1449 arg1 = (std::vector< int > *)jarg1;
1450 arg2 = (int)jarg2;
1451 arg3 = (std::vector< int > *)jarg3;
1452 if (!arg3) {
1453 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
1454 return ;
1455 }
1456 try {
1457 std_vector_Sl_int_Sg__SetRange(arg1,arg2,(std::vector< int > const &)*arg3);
1458 } catch(std::out_of_range &_e) {
1459 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1460 return ;
1461 }
1462}
1463
1464
1465SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Contains___(void * jarg1, int jarg2) {
1466 unsigned int jresult ;
1467 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1468 int *arg2 = 0 ;
1469 int temp2 ;
1470 bool result;
1471
1472 arg1 = (std::vector< int > *)jarg1;
1473 temp2 = (int)jarg2;
1474 arg2 = &temp2;
1475 result = (bool)std_vector_Sl_int_Sg__Contains(arg1,(int const &)*arg2);
1476 jresult = result;
1477 return jresult;
1478}
1479
1480
1481SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_IndexOf___(void * jarg1, int jarg2) {
1482 int jresult ;
1483 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1484 int *arg2 = 0 ;
1485 int temp2 ;
1486 int result;
1487
1488 arg1 = (std::vector< int > *)jarg1;
1489 temp2 = (int)jarg2;
1490 arg2 = &temp2;
1491 result = (int)std_vector_Sl_int_Sg__IndexOf(arg1,(int const &)*arg2);
1492 jresult = result;
1493 return jresult;
1494}
1495
1496
1497SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_LastIndexOf___(void * jarg1, int jarg2) {
1498 int jresult ;
1499 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1500 int *arg2 = 0 ;
1501 int temp2 ;
1502 int result;
1503
1504 arg1 = (std::vector< int > *)jarg1;
1505 temp2 = (int)jarg2;
1506 arg2 = &temp2;
1507 result = (int)std_vector_Sl_int_Sg__LastIndexOf(arg1,(int const &)*arg2);
1508 jresult = result;
1509 return jresult;
1510}
1511
1512
1513SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Remove___(void * jarg1, int jarg2) {
1514 unsigned int jresult ;
1515 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1516 int *arg2 = 0 ;
1517 int temp2 ;
1518 bool result;
1519
1520 arg1 = (std::vector< int > *)jarg1;
1521 temp2 = (int)jarg2;
1522 arg2 = &temp2;
1523 result = (bool)std_vector_Sl_int_Sg__Remove(arg1,(int const &)*arg2);
1524 jresult = result;
1525 return jresult;
1526}
1527
1528
1529SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_IntVector___(void * jarg1) {
1530 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1531
1532 arg1 = (std::vector< int > *)jarg1;
1533 delete arg1;
1534}
1535
1536
1537SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Clear___(void * jarg1) {
1538 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1539
1540 arg1 = (std::vector< std::vector< int > > *)jarg1;
1541 (arg1)->clear();
1542}
1543
1544
1545SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Add___(void * jarg1, void * jarg2) {
1546 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1547 std::vector< int > *arg2 = 0 ;
1548
1549 arg1 = (std::vector< std::vector< int > > *)jarg1;
1550 arg2 = (std::vector< int > *)jarg2;
1551 if (!arg2) {
1552 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
1553 return ;
1554 }
1555 (arg1)->push_back((std::vector< int > const &)*arg2);
1556}
1557
1558
1559SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_size___(void * jarg1) {
1560 unsigned long jresult ;
1561 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1562 std::vector< std::vector< int > >::size_type result;
1563
1564 arg1 = (std::vector< std::vector< int > > *)jarg1;
1565 result = ((std::vector< std::vector< int > > const *)arg1)->size();
1566 jresult = (unsigned long)result;
1567 return jresult;
1568}
1569
1570
1571SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_capacity___(void * jarg1) {
1572 unsigned long jresult ;
1573 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1574 std::vector< std::vector< int > >::size_type result;
1575
1576 arg1 = (std::vector< std::vector< int > > *)jarg1;
1577 result = ((std::vector< std::vector< int > > const *)arg1)->capacity();
1578 jresult = (unsigned long)result;
1579 return jresult;
1580}
1581
1582
1583SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_reserve___(void * jarg1, unsigned long jarg2) {
1584 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1585 std::vector< std::vector< int > >::size_type arg2 ;
1586
1587 arg1 = (std::vector< std::vector< int > > *)jarg1;
1588 arg2 = (std::vector< std::vector< int > >::size_type)jarg2;
1589 (arg1)->reserve(arg2);
1590}
1591
1592
1593SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVectorVector__SWIG_0___() {
1594 void * jresult ;
1595 std::vector< std::vector< int > > *result = 0 ;
1596
1597 result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >();
1598 jresult = (void *)result;
1599 return jresult;
1600}
1601
1602
1603SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVectorVector__SWIG_1___(void * jarg1) {
1604 void * jresult ;
1605 std::vector< std::vector< int > > *arg1 = 0 ;
1606 std::vector< std::vector< int > > *result = 0 ;
1607
1608 arg1 = (std::vector< std::vector< int > > *)jarg1;
1609 if (!arg1) {
1610 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
1611 return 0;
1612 }
1613 result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >((std::vector< std::vector< int > > const &)*arg1);
1614 jresult = (void *)result;
1615 return jresult;
1616}
1617
1618
1619SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVectorVector__SWIG_2___(int jarg1) {
1620 void * jresult ;
1621 int arg1 ;
1622 std::vector< std::vector< int > > *result = 0 ;
1623
1624 arg1 = (int)jarg1;
1625 try {
1626 result = (std::vector< std::vector< int > > *)new_std_vector_Sl_std_vector_Sl_int_Sg__Sg___SWIG_2(arg1);
1627 } catch(std::out_of_range &_e) {
1628 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1629 return 0;
1630 }
1631 jresult = (void *)result;
1632 return jresult;
1633}
1634
1635
1636SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_getitemcopy___(void * jarg1, int jarg2) {
1637 void * jresult ;
1638 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1639 int arg2 ;
1640 std::vector< int > result;
1641
1642 arg1 = (std::vector< std::vector< int > > *)jarg1;
1643 arg2 = (int)jarg2;
1644 try {
1645 result = std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitemcopy(arg1,arg2);
1646 } catch(std::out_of_range &_e) {
1647 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1648 return 0;
1649 }
1650 jresult = new std::vector< int >((const std::vector< int > &)result);
1651 return jresult;
1652}
1653
1654
1655SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_getitem___(void * jarg1, int jarg2) {
1656 void * jresult ;
1657 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1658 int arg2 ;
1659 std::vector< std::vector< int > >::value_type *result = 0 ;
1660
1661 arg1 = (std::vector< std::vector< int > > *)jarg1;
1662 arg2 = (int)jarg2;
1663 try {
1664 result = (std::vector< std::vector< int > >::value_type *) &std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitem(arg1,arg2);
1665 } catch(std::out_of_range &_e) {
1666 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1667 return 0;
1668 }
1669 jresult = (void *)result;
1670 return jresult;
1671}
1672
1673
1674SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
1675 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1676 int arg2 ;
1677 std::vector< int > *arg3 = 0 ;
1678
1679 arg1 = (std::vector< std::vector< int > > *)jarg1;
1680 arg2 = (int)jarg2;
1681 arg3 = (std::vector< int > *)jarg3;
1682 if (!arg3) {
1683 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
1684 return ;
1685 }
1686 try {
1687 std_vector_Sl_std_vector_Sl_int_Sg__Sg__setitem(arg1,arg2,(std::vector< int > const &)*arg3);
1688 } catch(std::out_of_range &_e) {
1689 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1690 return ;
1691 }
1692}
1693
1694
1695SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_AddRange___(void * jarg1, void * jarg2) {
1696 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1697 std::vector< std::vector< int > > *arg2 = 0 ;
1698
1699 arg1 = (std::vector< std::vector< int > > *)jarg1;
1700 arg2 = (std::vector< std::vector< int > > *)jarg2;
1701 if (!arg2) {
1702 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
1703 return ;
1704 }
1705 std_vector_Sl_std_vector_Sl_int_Sg__Sg__AddRange(arg1,(std::vector< std::vector< int > > const &)*arg2);
1706}
1707
1708
1709SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
1710 void * jresult ;
1711 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1712 int arg2 ;
1713 int arg3 ;
1714 std::vector< std::vector< int > > *result = 0 ;
1715
1716 arg1 = (std::vector< std::vector< int > > *)jarg1;
1717 arg2 = (int)jarg2;
1718 arg3 = (int)jarg3;
1719 try {
1720 result = (std::vector< std::vector< int > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg__GetRange(arg1,arg2,arg3);
1721 } catch(std::out_of_range &_e) {
1722 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1723 return 0;
1724 } catch(std::invalid_argument &_e) {
1725 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
1726 return 0;
1727 }
1728 jresult = (void *)result;
1729 return jresult;
1730}
1731
1732
1733SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
1734 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1735 int arg2 ;
1736 std::vector< int > *arg3 = 0 ;
1737
1738 arg1 = (std::vector< std::vector< int > > *)jarg1;
1739 arg2 = (int)jarg2;
1740 arg3 = (std::vector< int > *)jarg3;
1741 if (!arg3) {
1742 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
1743 return ;
1744 }
1745 try {
1746 std_vector_Sl_std_vector_Sl_int_Sg__Sg__Insert(arg1,arg2,(std::vector< int > const &)*arg3);
1747 } catch(std::out_of_range &_e) {
1748 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1749 return ;
1750 }
1751}
1752
1753
1754SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
1755 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1756 int arg2 ;
1757 std::vector< std::vector< int > > *arg3 = 0 ;
1758
1759 arg1 = (std::vector< std::vector< int > > *)jarg1;
1760 arg2 = (int)jarg2;
1761 arg3 = (std::vector< std::vector< int > > *)jarg3;
1762 if (!arg3) {
1763 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
1764 return ;
1765 }
1766 try {
1767 std_vector_Sl_std_vector_Sl_int_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< int > > const &)*arg3);
1768 } catch(std::out_of_range &_e) {
1769 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1770 return ;
1771 }
1772}
1773
1774
1775SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_RemoveAt___(void * jarg1, int jarg2) {
1776 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1777 int arg2 ;
1778
1779 arg1 = (std::vector< std::vector< int > > *)jarg1;
1780 arg2 = (int)jarg2;
1781 try {
1782 std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveAt(arg1,arg2);
1783 } catch(std::out_of_range &_e) {
1784 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1785 return ;
1786 }
1787}
1788
1789
1790SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
1791 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1792 int arg2 ;
1793 int arg3 ;
1794
1795 arg1 = (std::vector< std::vector< int > > *)jarg1;
1796 arg2 = (int)jarg2;
1797 arg3 = (int)jarg3;
1798 try {
1799 std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveRange(arg1,arg2,arg3);
1800 } catch(std::out_of_range &_e) {
1801 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1802 return ;
1803 } catch(std::invalid_argument &_e) {
1804 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
1805 return ;
1806 }
1807}
1808
1809
1810SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Repeat___(void * jarg1, int jarg2) {
1811 void * jresult ;
1812 std::vector< int > *arg1 = 0 ;
1813 int arg2 ;
1814 std::vector< std::vector< int > > *result = 0 ;
1815
1816 arg1 = (std::vector< int > *)jarg1;
1817 if (!arg1) {
1818 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
1819 return 0;
1820 }
1821 arg2 = (int)jarg2;
1822 try {
1823 result = (std::vector< std::vector< int > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg__Repeat((std::vector< int > const &)*arg1,arg2);
1824 } catch(std::out_of_range &_e) {
1825 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1826 return 0;
1827 }
1828 jresult = (void *)result;
1829 return jresult;
1830}
1831
1832
1833SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Reverse__SWIG_0___(void * jarg1) {
1834 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1835
1836 arg1 = (std::vector< std::vector< int > > *)jarg1;
1837 std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_0(arg1);
1838}
1839
1840
1841SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
1842 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1843 int arg2 ;
1844 int arg3 ;
1845
1846 arg1 = (std::vector< std::vector< int > > *)jarg1;
1847 arg2 = (int)jarg2;
1848 arg3 = (int)jarg3;
1849 try {
1850 std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
1851 } catch(std::out_of_range &_e) {
1852 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1853 return ;
1854 } catch(std::invalid_argument &_e) {
1855 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
1856 return ;
1857 }
1858}
1859
1860
1861SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
1862 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1863 int arg2 ;
1864 std::vector< std::vector< int > > *arg3 = 0 ;
1865
1866 arg1 = (std::vector< std::vector< int > > *)jarg1;
1867 arg2 = (int)jarg2;
1868 arg3 = (std::vector< std::vector< int > > *)jarg3;
1869 if (!arg3) {
1870 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
1871 return ;
1872 }
1873 try {
1874 std_vector_Sl_std_vector_Sl_int_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< int > > const &)*arg3);
1875 } catch(std::out_of_range &_e) {
1876 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1877 return ;
1878 }
1879}
1880
1881
1882SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_IntVectorVector___(void * jarg1) {
1883 std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
1884
1885 arg1 = (std::vector< std::vector< int > > *)jarg1;
1886 delete arg1;
1887}
1888
1889
1890SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Clear___(void * jarg1) {
1891 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
1892
1893 arg1 = (std::vector< int64_t > *)jarg1;
1894 (arg1)->clear();
1895}
1896
1897
1898SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Add___(void * jarg1, long long jarg2) {
1899 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
1900 long long *arg2 = 0 ;
1901 long long temp2 ;
1902
1903 arg1 = (std::vector< int64_t > *)jarg1;
1904 temp2 = (long long)jarg2;
1905 arg2 = &temp2;
1906 (arg1)->push_back((long long const &)*arg2);
1907}
1908
1909
1910SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_size___(void * jarg1) {
1911 unsigned long jresult ;
1912 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
1913 std::vector< long long >::size_type result;
1914
1915 arg1 = (std::vector< int64_t > *)jarg1;
1916 result = ((std::vector< int64_t > const *)arg1)->size();
1917 jresult = (unsigned long)result;
1918 return jresult;
1919}
1920
1921
1922SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_capacity___(void * jarg1) {
1923 unsigned long jresult ;
1924 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
1925 std::vector< long long >::size_type result;
1926
1927 arg1 = (std::vector< int64_t > *)jarg1;
1928 result = ((std::vector< int64_t > const *)arg1)->capacity();
1929 jresult = (unsigned long)result;
1930 return jresult;
1931}
1932
1933
1934SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_reserve___(void * jarg1, unsigned long jarg2) {
1935 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
1936 std::vector< long long >::size_type arg2 ;
1937
1938 arg1 = (std::vector< int64_t > *)jarg1;
1939 arg2 = (std::vector< long long >::size_type)jarg2;
1940 (arg1)->reserve(arg2);
1941}
1942
1943
1944SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64Vector__SWIG_0___() {
1945 void * jresult ;
1946 std::vector< int64_t > *result = 0 ;
1947
1948 result = (std::vector< int64_t > *)new std::vector< int64_t >();
1949 jresult = (void *)result;
1950 return jresult;
1951}
1952
1953
1954SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64Vector__SWIG_1___(void * jarg1) {
1955 void * jresult ;
1956 std::vector< int64_t > *arg1 = 0 ;
1957 std::vector< int64_t > *result = 0 ;
1958
1959 arg1 = (std::vector< int64_t > *)jarg1;
1960 if (!arg1) {
1961 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int64_t > const & type is null", 0);
1962 return 0;
1963 }
1964 result = (std::vector< int64_t > *)new std::vector< int64_t >((std::vector< int64_t > const &)*arg1);
1965 jresult = (void *)result;
1966 return jresult;
1967}
1968
1969
1970SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64Vector__SWIG_2___(int jarg1) {
1971 void * jresult ;
1972 int arg1 ;
1973 std::vector< int64_t > *result = 0 ;
1974
1975 arg1 = (int)jarg1;
1976 try {
1977 result = (std::vector< int64_t > *)new_std_vector_Sl_int64_t_Sg___SWIG_2(arg1);
1978 } catch(std::out_of_range &_e) {
1979 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1980 return 0;
1981 }
1982 jresult = (void *)result;
1983 return jresult;
1984}
1985
1986
1987SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_getitemcopy___(void * jarg1, int jarg2) {
1988 long long jresult ;
1989 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
1990 int arg2 ;
1991 long long result;
1992
1993 arg1 = (std::vector< int64_t > *)jarg1;
1994 arg2 = (int)jarg2;
1995 try {
1996 result = (long long)std_vector_Sl_int64_t_Sg__getitemcopy(arg1,arg2);
1997 } catch(std::out_of_range &_e) {
1998 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
1999 return 0;
2000 }
2001 jresult = result;
2002 return jresult;
2003}
2004
2005
2006SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_getitem___(void * jarg1, int jarg2) {
2007 long long jresult ;
2008 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2009 int arg2 ;
2010 std::vector< long long >::value_type *result = 0 ;
2011
2012 arg1 = (std::vector< int64_t > *)jarg1;
2013 arg2 = (int)jarg2;
2014 try {
2015 result = (std::vector< long long >::value_type *) &std_vector_Sl_int64_t_Sg__getitem(arg1,arg2);
2016 } catch(std::out_of_range &_e) {
2017 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2018 return 0;
2019 }
2020 jresult = *result;
2021 return jresult;
2022}
2023
2024
2025SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_setitem___(void * jarg1, int jarg2, long long jarg3) {
2026 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2027 int arg2 ;
2028 long long *arg3 = 0 ;
2029 long long temp3 ;
2030
2031 arg1 = (std::vector< int64_t > *)jarg1;
2032 arg2 = (int)jarg2;
2033 temp3 = (long long)jarg3;
2034 arg3 = &temp3;
2035 try {
2036 std_vector_Sl_int64_t_Sg__setitem(arg1,arg2,(long long const &)*arg3);
2037 } catch(std::out_of_range &_e) {
2038 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2039 return ;
2040 }
2041}
2042
2043
2044SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_AddRange___(void * jarg1, void * jarg2) {
2045 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2046 std::vector< long long > *arg2 = 0 ;
2047
2048 arg1 = (std::vector< int64_t > *)jarg1;
2049 arg2 = (std::vector< long long > *)jarg2;
2050 if (!arg2) {
2051 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< long long > const & type is null", 0);
2052 return ;
2053 }
2054 std_vector_Sl_int64_t_Sg__AddRange(arg1,(std::vector< long long > const &)*arg2);
2055}
2056
2057
2058SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_GetRange___(void * jarg1, int jarg2, int jarg3) {
2059 void * jresult ;
2060 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2061 int arg2 ;
2062 int arg3 ;
2063 std::vector< long long > *result = 0 ;
2064
2065 arg1 = (std::vector< int64_t > *)jarg1;
2066 arg2 = (int)jarg2;
2067 arg3 = (int)jarg3;
2068 try {
2069 result = (std::vector< long long > *)std_vector_Sl_int64_t_Sg__GetRange(arg1,arg2,arg3);
2070 } catch(std::out_of_range &_e) {
2071 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2072 return 0;
2073 } catch(std::invalid_argument &_e) {
2074 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
2075 return 0;
2076 }
2077 jresult = (void *)result;
2078 return jresult;
2079}
2080
2081
2082SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Insert___(void * jarg1, int jarg2, long long jarg3) {
2083 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2084 int arg2 ;
2085 long long *arg3 = 0 ;
2086 long long temp3 ;
2087
2088 arg1 = (std::vector< int64_t > *)jarg1;
2089 arg2 = (int)jarg2;
2090 temp3 = (long long)jarg3;
2091 arg3 = &temp3;
2092 try {
2093 std_vector_Sl_int64_t_Sg__Insert(arg1,arg2,(long long const &)*arg3);
2094 } catch(std::out_of_range &_e) {
2095 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2096 return ;
2097 }
2098}
2099
2100
2101SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
2102 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2103 int arg2 ;
2104 std::vector< long long > *arg3 = 0 ;
2105
2106 arg1 = (std::vector< int64_t > *)jarg1;
2107 arg2 = (int)jarg2;
2108 arg3 = (std::vector< long long > *)jarg3;
2109 if (!arg3) {
2110 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< long long > const & type is null", 0);
2111 return ;
2112 }
2113 try {
2114 std_vector_Sl_int64_t_Sg__InsertRange(arg1,arg2,(std::vector< long long > const &)*arg3);
2115 } catch(std::out_of_range &_e) {
2116 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2117 return ;
2118 }
2119}
2120
2121
2122SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_RemoveAt___(void * jarg1, int jarg2) {
2123 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2124 int arg2 ;
2125
2126 arg1 = (std::vector< int64_t > *)jarg1;
2127 arg2 = (int)jarg2;
2128 try {
2129 std_vector_Sl_int64_t_Sg__RemoveAt(arg1,arg2);
2130 } catch(std::out_of_range &_e) {
2131 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2132 return ;
2133 }
2134}
2135
2136
2137SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
2138 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2139 int arg2 ;
2140 int arg3 ;
2141
2142 arg1 = (std::vector< int64_t > *)jarg1;
2143 arg2 = (int)jarg2;
2144 arg3 = (int)jarg3;
2145 try {
2146 std_vector_Sl_int64_t_Sg__RemoveRange(arg1,arg2,arg3);
2147 } catch(std::out_of_range &_e) {
2148 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2149 return ;
2150 } catch(std::invalid_argument &_e) {
2151 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
2152 return ;
2153 }
2154}
2155
2156
2157SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Repeat___(long long jarg1, int jarg2) {
2158 void * jresult ;
2159 long long *arg1 = 0 ;
2160 int arg2 ;
2161 long long temp1 ;
2162 std::vector< long long > *result = 0 ;
2163
2164 temp1 = (long long)jarg1;
2165 arg1 = &temp1;
2166 arg2 = (int)jarg2;
2167 try {
2168 result = (std::vector< long long > *)std_vector_Sl_int64_t_Sg__Repeat((long long const &)*arg1,arg2);
2169 } catch(std::out_of_range &_e) {
2170 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2171 return 0;
2172 }
2173 jresult = (void *)result;
2174 return jresult;
2175}
2176
2177
2178SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Reverse__SWIG_0___(void * jarg1) {
2179 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2180
2181 arg1 = (std::vector< int64_t > *)jarg1;
2182 std_vector_Sl_int64_t_Sg__Reverse__SWIG_0(arg1);
2183}
2184
2185
2186SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
2187 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2188 int arg2 ;
2189 int arg3 ;
2190
2191 arg1 = (std::vector< int64_t > *)jarg1;
2192 arg2 = (int)jarg2;
2193 arg3 = (int)jarg3;
2194 try {
2195 std_vector_Sl_int64_t_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
2196 } catch(std::out_of_range &_e) {
2197 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2198 return ;
2199 } catch(std::invalid_argument &_e) {
2200 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
2201 return ;
2202 }
2203}
2204
2205
2206SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
2207 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2208 int arg2 ;
2209 std::vector< long long > *arg3 = 0 ;
2210
2211 arg1 = (std::vector< int64_t > *)jarg1;
2212 arg2 = (int)jarg2;
2213 arg3 = (std::vector< long long > *)jarg3;
2214 if (!arg3) {
2215 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< long long > const & type is null", 0);
2216 return ;
2217 }
2218 try {
2219 std_vector_Sl_int64_t_Sg__SetRange(arg1,arg2,(std::vector< long long > const &)*arg3);
2220 } catch(std::out_of_range &_e) {
2221 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2222 return ;
2223 }
2224}
2225
2226
2227SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Contains___(void * jarg1, long long jarg2) {
2228 unsigned int jresult ;
2229 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2230 long long *arg2 = 0 ;
2231 long long temp2 ;
2232 bool result;
2233
2234 arg1 = (std::vector< int64_t > *)jarg1;
2235 temp2 = (long long)jarg2;
2236 arg2 = &temp2;
2237 result = (bool)std_vector_Sl_int64_t_Sg__Contains(arg1,(long long const &)*arg2);
2238 jresult = result;
2239 return jresult;
2240}
2241
2242
2243SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_IndexOf___(void * jarg1, long long jarg2) {
2244 int jresult ;
2245 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2246 long long *arg2 = 0 ;
2247 long long temp2 ;
2248 int result;
2249
2250 arg1 = (std::vector< int64_t > *)jarg1;
2251 temp2 = (long long)jarg2;
2252 arg2 = &temp2;
2253 result = (int)std_vector_Sl_int64_t_Sg__IndexOf(arg1,(long long const &)*arg2);
2254 jresult = result;
2255 return jresult;
2256}
2257
2258
2259SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_LastIndexOf___(void * jarg1, long long jarg2) {
2260 int jresult ;
2261 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2262 long long *arg2 = 0 ;
2263 long long temp2 ;
2264 int result;
2265
2266 arg1 = (std::vector< int64_t > *)jarg1;
2267 temp2 = (long long)jarg2;
2268 arg2 = &temp2;
2269 result = (int)std_vector_Sl_int64_t_Sg__LastIndexOf(arg1,(long long const &)*arg2);
2270 jresult = result;
2271 return jresult;
2272}
2273
2274
2275SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Remove___(void * jarg1, long long jarg2) {
2276 unsigned int jresult ;
2277 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2278 long long *arg2 = 0 ;
2279 long long temp2 ;
2280 bool result;
2281
2282 arg1 = (std::vector< int64_t > *)jarg1;
2283 temp2 = (long long)jarg2;
2284 arg2 = &temp2;
2285 result = (bool)std_vector_Sl_int64_t_Sg__Remove(arg1,(long long const &)*arg2);
2286 jresult = result;
2287 return jresult;
2288}
2289
2290
2291SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Int64Vector___(void * jarg1) {
2292 std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
2293
2294 arg1 = (std::vector< int64_t > *)jarg1;
2295 delete arg1;
2296}
2297
2298
2299SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Clear___(void * jarg1) {
2300 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2301
2302 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2303 (arg1)->clear();
2304}
2305
2306
2307SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Add___(void * jarg1, void * jarg2) {
2308 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2309 std::vector< int64_t > *arg2 = 0 ;
2310
2311 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2312 arg2 = (std::vector< int64_t > *)jarg2;
2313 if (!arg2) {
2314 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int64_t > const & type is null", 0);
2315 return ;
2316 }
2317 (arg1)->push_back((std::vector< int64_t > const &)*arg2);
2318}
2319
2320
2321SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_size___(void * jarg1) {
2322 unsigned long jresult ;
2323 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2324 std::vector< std::vector< long long > >::size_type result;
2325
2326 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2327 result = ((std::vector< std::vector< int64_t > > const *)arg1)->size();
2328 jresult = (unsigned long)result;
2329 return jresult;
2330}
2331
2332
2333SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_capacity___(void * jarg1) {
2334 unsigned long jresult ;
2335 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2336 std::vector< std::vector< long long > >::size_type result;
2337
2338 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2339 result = ((std::vector< std::vector< int64_t > > const *)arg1)->capacity();
2340 jresult = (unsigned long)result;
2341 return jresult;
2342}
2343
2344
2345SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_reserve___(void * jarg1, unsigned long jarg2) {
2346 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2347 std::vector< std::vector< long long > >::size_type arg2 ;
2348
2349 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2350 arg2 = (std::vector< std::vector< long long > >::size_type)jarg2;
2351 (arg1)->reserve(arg2);
2352}
2353
2354
2355SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64VectorVector__SWIG_0___() {
2356 void * jresult ;
2357 std::vector< std::vector< int64_t > > *result = 0 ;
2358
2359 result = (std::vector< std::vector< int64_t > > *)new std::vector< std::vector< int64_t > >();
2360 jresult = (void *)result;
2361 return jresult;
2362}
2363
2364
2365SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64VectorVector__SWIG_1___(void * jarg1) {
2366 void * jresult ;
2367 std::vector< std::vector< int64_t > > *arg1 = 0 ;
2368 std::vector< std::vector< int64_t > > *result = 0 ;
2369
2370 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2371 if (!arg1) {
2372 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int64_t > > const & type is null", 0);
2373 return 0;
2374 }
2375 result = (std::vector< std::vector< int64_t > > *)new std::vector< std::vector< int64_t > >((std::vector< std::vector< int64_t > > const &)*arg1);
2376 jresult = (void *)result;
2377 return jresult;
2378}
2379
2380
2381SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64VectorVector__SWIG_2___(int jarg1) {
2382 void * jresult ;
2383 int arg1 ;
2384 std::vector< std::vector< int64_t > > *result = 0 ;
2385
2386 arg1 = (int)jarg1;
2387 try {
2388 result = (std::vector< std::vector< int64_t > > *)new_std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg___SWIG_2(arg1);
2389 } catch(std::out_of_range &_e) {
2390 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2391 return 0;
2392 }
2393 jresult = (void *)result;
2394 return jresult;
2395}
2396
2397
2398SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_getitemcopy___(void * jarg1, int jarg2) {
2399 void * jresult ;
2400 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2401 int arg2 ;
2402 std::vector< int64_t > result;
2403
2404 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2405 arg2 = (int)jarg2;
2406 try {
2407 result = std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitemcopy(arg1,arg2);
2408 } catch(std::out_of_range &_e) {
2409 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2410 return 0;
2411 }
2412 jresult = new std::vector< int64_t >((const std::vector< int64_t > &)result);
2413 return jresult;
2414}
2415
2416
2417SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_getitem___(void * jarg1, int jarg2) {
2418 void * jresult ;
2419 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2420 int arg2 ;
2421 std::vector< std::vector< long long > >::value_type *result = 0 ;
2422
2423 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2424 arg2 = (int)jarg2;
2425 try {
2426 result = (std::vector< std::vector< long long > >::value_type *) &std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitem(arg1,arg2);
2427 } catch(std::out_of_range &_e) {
2428 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2429 return 0;
2430 }
2431 jresult = (void *)result;
2432 return jresult;
2433}
2434
2435
2436SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
2437 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2438 int arg2 ;
2439 std::vector< int64_t > *arg3 = 0 ;
2440
2441 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2442 arg2 = (int)jarg2;
2443 arg3 = (std::vector< int64_t > *)jarg3;
2444 if (!arg3) {
2445 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int64_t > const & type is null", 0);
2446 return ;
2447 }
2448 try {
2449 std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__setitem(arg1,arg2,(std::vector< long long > const &)*arg3);
2450 } catch(std::out_of_range &_e) {
2451 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2452 return ;
2453 }
2454}
2455
2456
2457SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_AddRange___(void * jarg1, void * jarg2) {
2458 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2459 std::vector< std::vector< int64_t > > *arg2 = 0 ;
2460
2461 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2462 arg2 = (std::vector< std::vector< int64_t > > *)jarg2;
2463 if (!arg2) {
2464 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int64_t > > const & type is null", 0);
2465 return ;
2466 }
2467 std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__AddRange(arg1,(std::vector< std::vector< long long > > const &)*arg2);
2468}
2469
2470
2471SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
2472 void * jresult ;
2473 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2474 int arg2 ;
2475 int arg3 ;
2476 std::vector< std::vector< int64_t > > *result = 0 ;
2477
2478 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2479 arg2 = (int)jarg2;
2480 arg3 = (int)jarg3;
2481 try {
2482 result = (std::vector< std::vector< int64_t > > *)std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__GetRange(arg1,arg2,arg3);
2483 } catch(std::out_of_range &_e) {
2484 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2485 return 0;
2486 } catch(std::invalid_argument &_e) {
2487 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
2488 return 0;
2489 }
2490 jresult = (void *)result;
2491 return jresult;
2492}
2493
2494
2495SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
2496 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2497 int arg2 ;
2498 std::vector< int64_t > *arg3 = 0 ;
2499
2500 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2501 arg2 = (int)jarg2;
2502 arg3 = (std::vector< int64_t > *)jarg3;
2503 if (!arg3) {
2504 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int64_t > const & type is null", 0);
2505 return ;
2506 }
2507 try {
2508 std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Insert(arg1,arg2,(std::vector< long long > const &)*arg3);
2509 } catch(std::out_of_range &_e) {
2510 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2511 return ;
2512 }
2513}
2514
2515
2516SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
2517 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2518 int arg2 ;
2519 std::vector< std::vector< int64_t > > *arg3 = 0 ;
2520
2521 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2522 arg2 = (int)jarg2;
2523 arg3 = (std::vector< std::vector< int64_t > > *)jarg3;
2524 if (!arg3) {
2525 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int64_t > > const & type is null", 0);
2526 return ;
2527 }
2528 try {
2529 std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< long long > > const &)*arg3);
2530 } catch(std::out_of_range &_e) {
2531 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2532 return ;
2533 }
2534}
2535
2536
2537SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_RemoveAt___(void * jarg1, int jarg2) {
2538 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2539 int arg2 ;
2540
2541 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2542 arg2 = (int)jarg2;
2543 try {
2544 std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveAt(arg1,arg2);
2545 } catch(std::out_of_range &_e) {
2546 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2547 return ;
2548 }
2549}
2550
2551
2552SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
2553 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2554 int arg2 ;
2555 int arg3 ;
2556
2557 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2558 arg2 = (int)jarg2;
2559 arg3 = (int)jarg3;
2560 try {
2561 std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveRange(arg1,arg2,arg3);
2562 } catch(std::out_of_range &_e) {
2563 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2564 return ;
2565 } catch(std::invalid_argument &_e) {
2566 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
2567 return ;
2568 }
2569}
2570
2571
2572SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Repeat___(void * jarg1, int jarg2) {
2573 void * jresult ;
2574 std::vector< int64_t > *arg1 = 0 ;
2575 int arg2 ;
2576 std::vector< std::vector< int64_t > > *result = 0 ;
2577
2578 arg1 = (std::vector< int64_t > *)jarg1;
2579 if (!arg1) {
2580 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int64_t > const & type is null", 0);
2581 return 0;
2582 }
2583 arg2 = (int)jarg2;
2584 try {
2585 result = (std::vector< std::vector< int64_t > > *)std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Repeat((std::vector< long long > const &)*arg1,arg2);
2586 } catch(std::out_of_range &_e) {
2587 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2588 return 0;
2589 }
2590 jresult = (void *)result;
2591 return jresult;
2592}
2593
2594
2595SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Reverse__SWIG_0___(void * jarg1) {
2596 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2597
2598 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2599 std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_0(arg1);
2600}
2601
2602
2603SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
2604 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2605 int arg2 ;
2606 int arg3 ;
2607
2608 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2609 arg2 = (int)jarg2;
2610 arg3 = (int)jarg3;
2611 try {
2612 std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
2613 } catch(std::out_of_range &_e) {
2614 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2615 return ;
2616 } catch(std::invalid_argument &_e) {
2617 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
2618 return ;
2619 }
2620}
2621
2622
2623SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
2624 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2625 int arg2 ;
2626 std::vector< std::vector< int64_t > > *arg3 = 0 ;
2627
2628 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2629 arg2 = (int)jarg2;
2630 arg3 = (std::vector< std::vector< int64_t > > *)jarg3;
2631 if (!arg3) {
2632 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int64_t > > const & type is null", 0);
2633 return ;
2634 }
2635 try {
2636 std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< long long > > const &)*arg3);
2637 } catch(std::out_of_range &_e) {
2638 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2639 return ;
2640 }
2641}
2642
2643
2644SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Int64VectorVector___(void * jarg1) {
2645 std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
2646
2647 arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
2648 delete arg1;
2649}
2650
2651
2652SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Clear___(void * jarg1) {
2653 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2654
2655 arg1 = (std::vector< double > *)jarg1;
2656 (arg1)->clear();
2657}
2658
2659
2660SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Add___(void * jarg1, double jarg2) {
2661 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2662 double *arg2 = 0 ;
2663 double temp2 ;
2664
2665 arg1 = (std::vector< double > *)jarg1;
2666 temp2 = (double)jarg2;
2667 arg2 = &temp2;
2668 (arg1)->push_back((double const &)*arg2);
2669}
2670
2671
2672SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_size___(void * jarg1) {
2673 unsigned long jresult ;
2674 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2675 std::vector< double >::size_type result;
2676
2677 arg1 = (std::vector< double > *)jarg1;
2678 result = ((std::vector< double > const *)arg1)->size();
2679 jresult = (unsigned long)result;
2680 return jresult;
2681}
2682
2683
2684SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_capacity___(void * jarg1) {
2685 unsigned long jresult ;
2686 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2687 std::vector< double >::size_type result;
2688
2689 arg1 = (std::vector< double > *)jarg1;
2690 result = ((std::vector< double > const *)arg1)->capacity();
2691 jresult = (unsigned long)result;
2692 return jresult;
2693}
2694
2695
2696SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_reserve___(void * jarg1, unsigned long jarg2) {
2697 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2698 std::vector< double >::size_type arg2 ;
2699
2700 arg1 = (std::vector< double > *)jarg1;
2701 arg2 = (std::vector< double >::size_type)jarg2;
2702 (arg1)->reserve(arg2);
2703}
2704
2705
2706SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_DoubleVector__SWIG_0___() {
2707 void * jresult ;
2708 std::vector< double > *result = 0 ;
2709
2710 result = (std::vector< double > *)new std::vector< double >();
2711 jresult = (void *)result;
2712 return jresult;
2713}
2714
2715
2716SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_DoubleVector__SWIG_1___(void * jarg1) {
2717 void * jresult ;
2718 std::vector< double > *arg1 = 0 ;
2719 std::vector< double > *result = 0 ;
2720
2721 arg1 = (std::vector< double > *)jarg1;
2722 if (!arg1) {
2723 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
2724 return 0;
2725 }
2726 result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
2727 jresult = (void *)result;
2728 return jresult;
2729}
2730
2731
2732SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_DoubleVector__SWIG_2___(int jarg1) {
2733 void * jresult ;
2734 int arg1 ;
2735 std::vector< double > *result = 0 ;
2736
2737 arg1 = (int)jarg1;
2738 try {
2739 result = (std::vector< double > *)new_std_vector_Sl_double_Sg___SWIG_2(arg1);
2740 } catch(std::out_of_range &_e) {
2741 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2742 return 0;
2743 }
2744 jresult = (void *)result;
2745 return jresult;
2746}
2747
2748
2749SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_getitemcopy___(void * jarg1, int jarg2) {
2750 double jresult ;
2751 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2752 int arg2 ;
2753 double result;
2754
2755 arg1 = (std::vector< double > *)jarg1;
2756 arg2 = (int)jarg2;
2757 try {
2758 result = (double)std_vector_Sl_double_Sg__getitemcopy(arg1,arg2);
2759 } catch(std::out_of_range &_e) {
2760 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2761 return 0;
2762 }
2763 jresult = result;
2764 return jresult;
2765}
2766
2767
2768SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_getitem___(void * jarg1, int jarg2) {
2769 double jresult ;
2770 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2771 int arg2 ;
2772 std::vector< double >::value_type *result = 0 ;
2773
2774 arg1 = (std::vector< double > *)jarg1;
2775 arg2 = (int)jarg2;
2776 try {
2777 result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__getitem(arg1,arg2);
2778 } catch(std::out_of_range &_e) {
2779 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2780 return 0;
2781 }
2782 jresult = *result;
2783 return jresult;
2784}
2785
2786
2787SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_setitem___(void * jarg1, int jarg2, double jarg3) {
2788 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2789 int arg2 ;
2790 double *arg3 = 0 ;
2791 double temp3 ;
2792
2793 arg1 = (std::vector< double > *)jarg1;
2794 arg2 = (int)jarg2;
2795 temp3 = (double)jarg3;
2796 arg3 = &temp3;
2797 try {
2798 std_vector_Sl_double_Sg__setitem(arg1,arg2,(double const &)*arg3);
2799 } catch(std::out_of_range &_e) {
2800 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2801 return ;
2802 }
2803}
2804
2805
2806SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_AddRange___(void * jarg1, void * jarg2) {
2807 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2808 std::vector< double > *arg2 = 0 ;
2809
2810 arg1 = (std::vector< double > *)jarg1;
2811 arg2 = (std::vector< double > *)jarg2;
2812 if (!arg2) {
2813 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
2814 return ;
2815 }
2816 std_vector_Sl_double_Sg__AddRange(arg1,(std::vector< double > const &)*arg2);
2817}
2818
2819
2820SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
2821 void * jresult ;
2822 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2823 int arg2 ;
2824 int arg3 ;
2825 std::vector< double > *result = 0 ;
2826
2827 arg1 = (std::vector< double > *)jarg1;
2828 arg2 = (int)jarg2;
2829 arg3 = (int)jarg3;
2830 try {
2831 result = (std::vector< double > *)std_vector_Sl_double_Sg__GetRange(arg1,arg2,arg3);
2832 } catch(std::out_of_range &_e) {
2833 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2834 return 0;
2835 } catch(std::invalid_argument &_e) {
2836 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
2837 return 0;
2838 }
2839 jresult = (void *)result;
2840 return jresult;
2841}
2842
2843
2844SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Insert___(void * jarg1, int jarg2, double jarg3) {
2845 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2846 int arg2 ;
2847 double *arg3 = 0 ;
2848 double temp3 ;
2849
2850 arg1 = (std::vector< double > *)jarg1;
2851 arg2 = (int)jarg2;
2852 temp3 = (double)jarg3;
2853 arg3 = &temp3;
2854 try {
2855 std_vector_Sl_double_Sg__Insert(arg1,arg2,(double const &)*arg3);
2856 } catch(std::out_of_range &_e) {
2857 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2858 return ;
2859 }
2860}
2861
2862
2863SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
2864 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2865 int arg2 ;
2866 std::vector< double > *arg3 = 0 ;
2867
2868 arg1 = (std::vector< double > *)jarg1;
2869 arg2 = (int)jarg2;
2870 arg3 = (std::vector< double > *)jarg3;
2871 if (!arg3) {
2872 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
2873 return ;
2874 }
2875 try {
2876 std_vector_Sl_double_Sg__InsertRange(arg1,arg2,(std::vector< double > const &)*arg3);
2877 } catch(std::out_of_range &_e) {
2878 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2879 return ;
2880 }
2881}
2882
2883
2884SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_RemoveAt___(void * jarg1, int jarg2) {
2885 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2886 int arg2 ;
2887
2888 arg1 = (std::vector< double > *)jarg1;
2889 arg2 = (int)jarg2;
2890 try {
2891 std_vector_Sl_double_Sg__RemoveAt(arg1,arg2);
2892 } catch(std::out_of_range &_e) {
2893 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2894 return ;
2895 }
2896}
2897
2898
2899SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
2900 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2901 int arg2 ;
2902 int arg3 ;
2903
2904 arg1 = (std::vector< double > *)jarg1;
2905 arg2 = (int)jarg2;
2906 arg3 = (int)jarg3;
2907 try {
2908 std_vector_Sl_double_Sg__RemoveRange(arg1,arg2,arg3);
2909 } catch(std::out_of_range &_e) {
2910 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2911 return ;
2912 } catch(std::invalid_argument &_e) {
2913 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
2914 return ;
2915 }
2916}
2917
2918
2919SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Repeat___(double jarg1, int jarg2) {
2920 void * jresult ;
2921 double *arg1 = 0 ;
2922 int arg2 ;
2923 double temp1 ;
2924 std::vector< double > *result = 0 ;
2925
2926 temp1 = (double)jarg1;
2927 arg1 = &temp1;
2928 arg2 = (int)jarg2;
2929 try {
2930 result = (std::vector< double > *)std_vector_Sl_double_Sg__Repeat((double const &)*arg1,arg2);
2931 } catch(std::out_of_range &_e) {
2932 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2933 return 0;
2934 }
2935 jresult = (void *)result;
2936 return jresult;
2937}
2938
2939
2940SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Reverse__SWIG_0___(void * jarg1) {
2941 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2942
2943 arg1 = (std::vector< double > *)jarg1;
2944 std_vector_Sl_double_Sg__Reverse__SWIG_0(arg1);
2945}
2946
2947
2948SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
2949 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2950 int arg2 ;
2951 int arg3 ;
2952
2953 arg1 = (std::vector< double > *)jarg1;
2954 arg2 = (int)jarg2;
2955 arg3 = (int)jarg3;
2956 try {
2957 std_vector_Sl_double_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
2958 } catch(std::out_of_range &_e) {
2959 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2960 return ;
2961 } catch(std::invalid_argument &_e) {
2962 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
2963 return ;
2964 }
2965}
2966
2967
2968SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
2969 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2970 int arg2 ;
2971 std::vector< double > *arg3 = 0 ;
2972
2973 arg1 = (std::vector< double > *)jarg1;
2974 arg2 = (int)jarg2;
2975 arg3 = (std::vector< double > *)jarg3;
2976 if (!arg3) {
2977 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
2978 return ;
2979 }
2980 try {
2981 std_vector_Sl_double_Sg__SetRange(arg1,arg2,(std::vector< double > const &)*arg3);
2982 } catch(std::out_of_range &_e) {
2983 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
2984 return ;
2985 }
2986}
2987
2988
2989SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Contains___(void * jarg1, double jarg2) {
2990 unsigned int jresult ;
2991 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2992 double *arg2 = 0 ;
2993 double temp2 ;
2994 bool result;
2995
2996 arg1 = (std::vector< double > *)jarg1;
2997 temp2 = (double)jarg2;
2998 arg2 = &temp2;
2999 result = (bool)std_vector_Sl_double_Sg__Contains(arg1,(double const &)*arg2);
3000 jresult = result;
3001 return jresult;
3002}
3003
3004
3005SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_IndexOf___(void * jarg1, double jarg2) {
3006 int jresult ;
3007 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
3008 double *arg2 = 0 ;
3009 double temp2 ;
3010 int result;
3011
3012 arg1 = (std::vector< double > *)jarg1;
3013 temp2 = (double)jarg2;
3014 arg2 = &temp2;
3015 result = (int)std_vector_Sl_double_Sg__IndexOf(arg1,(double const &)*arg2);
3016 jresult = result;
3017 return jresult;
3018}
3019
3020
3021SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_LastIndexOf___(void * jarg1, double jarg2) {
3022 int jresult ;
3023 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
3024 double *arg2 = 0 ;
3025 double temp2 ;
3026 int result;
3027
3028 arg1 = (std::vector< double > *)jarg1;
3029 temp2 = (double)jarg2;
3030 arg2 = &temp2;
3031 result = (int)std_vector_Sl_double_Sg__LastIndexOf(arg1,(double const &)*arg2);
3032 jresult = result;
3033 return jresult;
3034}
3035
3036
3037SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Remove___(void * jarg1, double jarg2) {
3038 unsigned int jresult ;
3039 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
3040 double *arg2 = 0 ;
3041 double temp2 ;
3042 bool result;
3043
3044 arg1 = (std::vector< double > *)jarg1;
3045 temp2 = (double)jarg2;
3046 arg2 = &temp2;
3047 result = (bool)std_vector_Sl_double_Sg__Remove(arg1,(double const &)*arg2);
3048 jresult = result;
3049 return jresult;
3050}
3051
3052
3053SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_DoubleVector___(void * jarg1) {
3054 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
3055
3056 arg1 = (std::vector< double > *)jarg1;
3057 delete arg1;
3058}
3059
3060
3061SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Clear___(void * jarg1) {
3062 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3063
3064 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3065 (arg1)->clear();
3066}
3067
3068
3069SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Add___(void * jarg1, void * jarg2) {
3070 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3071 operations_research::MPConstraint **arg2 = 0 ;
3072 operations_research::MPConstraint *temp2 = 0 ;
3073
3074 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3075 temp2 = (operations_research::MPConstraint *)jarg2;
3076 arg2 = (operations_research::MPConstraint **)&temp2;
3077 (arg1)->push_back((operations_research::MPConstraint *const &)*arg2);
3078}
3079
3080
3081SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_size___(void * jarg1) {
3082 unsigned long jresult ;
3083 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3084 std::vector< operations_research::MPConstraint * >::size_type result;
3085
3086 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3087 result = ((std::vector< operations_research::MPConstraint * > const *)arg1)->size();
3088 jresult = (unsigned long)result;
3089 return jresult;
3090}
3091
3092
3093SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_capacity___(void * jarg1) {
3094 unsigned long jresult ;
3095 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3096 std::vector< operations_research::MPConstraint * >::size_type result;
3097
3098 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3099 result = ((std::vector< operations_research::MPConstraint * > const *)arg1)->capacity();
3100 jresult = (unsigned long)result;
3101 return jresult;
3102}
3103
3104
3105SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_reserve___(void * jarg1, unsigned long jarg2) {
3106 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3107 std::vector< operations_research::MPConstraint * >::size_type arg2 ;
3108
3109 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3110 arg2 = (std::vector< operations_research::MPConstraint * >::size_type)jarg2;
3111 (arg1)->reserve(arg2);
3112}
3113
3114
3115SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPConstraintVector__SWIG_0___() {
3116 void * jresult ;
3117 std::vector< operations_research::MPConstraint * > *result = 0 ;
3118
3119 result = (std::vector< operations_research::MPConstraint * > *)new std::vector< operations_research::MPConstraint * >();
3120 jresult = (void *)result;
3121 return jresult;
3122}
3123
3124
3125SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPConstraintVector__SWIG_1___(void * jarg1) {
3126 void * jresult ;
3127 std::vector< operations_research::MPConstraint * > *arg1 = 0 ;
3128 std::vector< operations_research::MPConstraint * > *result = 0 ;
3129
3130 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3131 if (!arg1) {
3132 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::MPConstraint * > const & type is null", 0);
3133 return 0;
3134 }
3135 result = (std::vector< operations_research::MPConstraint * > *)new std::vector< operations_research::MPConstraint * >((std::vector< operations_research::MPConstraint * > const &)*arg1);
3136 jresult = (void *)result;
3137 return jresult;
3138}
3139
3140
3141SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPConstraintVector__SWIG_2___(int jarg1) {
3142 void * jresult ;
3143 int arg1 ;
3144 std::vector< operations_research::MPConstraint * > *result = 0 ;
3145
3146 arg1 = (int)jarg1;
3147 try {
3148 result = (std::vector< operations_research::MPConstraint * > *)new_std_vector_Sl_operations_research_MPConstraint_Sm__Sg___SWIG_2(arg1);
3149 } catch(std::out_of_range &_e) {
3150 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3151 return 0;
3152 }
3153 jresult = (void *)result;
3154 return jresult;
3155}
3156
3157
3158SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_getitemcopy___(void * jarg1, int jarg2) {
3159 void * jresult ;
3160 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3161 int arg2 ;
3162 operations_research::MPConstraint *result = 0 ;
3163
3164 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3165 arg2 = (int)jarg2;
3166 try {
3167 result = (operations_research::MPConstraint *)std_vector_Sl_operations_research_MPConstraint_Sm__Sg__getitemcopy(arg1,arg2);
3168 } catch(std::out_of_range &_e) {
3169 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3170 return 0;
3171 }
3172 jresult = (void *)result;
3173 return jresult;
3174}
3175
3176
3177SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_getitem___(void * jarg1, int jarg2) {
3178 void * jresult ;
3179 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3180 int arg2 ;
3181 std::vector< operations_research::MPConstraint * >::value_type *result = 0 ;
3182
3183 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3184 arg2 = (int)jarg2;
3185 try {
3186 result = (std::vector< operations_research::MPConstraint * >::value_type *) &std_vector_Sl_operations_research_MPConstraint_Sm__Sg__getitem(arg1,arg2);
3187 } catch(std::out_of_range &_e) {
3188 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3189 return 0;
3190 }
3191 jresult = (void *)*result;
3192 return jresult;
3193}
3194
3195
3196SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
3197 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3198 int arg2 ;
3199 operations_research::MPConstraint **arg3 = 0 ;
3200 operations_research::MPConstraint *temp3 = 0 ;
3201
3202 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3203 arg2 = (int)jarg2;
3204 temp3 = (operations_research::MPConstraint *)jarg3;
3205 arg3 = (operations_research::MPConstraint **)&temp3;
3206 try {
3207 std_vector_Sl_operations_research_MPConstraint_Sm__Sg__setitem(arg1,arg2,(operations_research::MPConstraint *const &)*arg3);
3208 } catch(std::out_of_range &_e) {
3209 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3210 return ;
3211 }
3212}
3213
3214
3215SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_AddRange___(void * jarg1, void * jarg2) {
3216 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3217 std::vector< operations_research::MPConstraint * > *arg2 = 0 ;
3218
3219 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3220 arg2 = (std::vector< operations_research::MPConstraint * > *)jarg2;
3221 if (!arg2) {
3222 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::MPConstraint * > const & type is null", 0);
3223 return ;
3224 }
3225 std_vector_Sl_operations_research_MPConstraint_Sm__Sg__AddRange(arg1,(std::vector< operations_research::MPConstraint * > const &)*arg2);
3226}
3227
3228
3229SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
3230 void * jresult ;
3231 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3232 int arg2 ;
3233 int arg3 ;
3234 std::vector< operations_research::MPConstraint * > *result = 0 ;
3235
3236 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3237 arg2 = (int)jarg2;
3238 arg3 = (int)jarg3;
3239 try {
3240 result = (std::vector< operations_research::MPConstraint * > *)std_vector_Sl_operations_research_MPConstraint_Sm__Sg__GetRange(arg1,arg2,arg3);
3241 } catch(std::out_of_range &_e) {
3242 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3243 return 0;
3244 } catch(std::invalid_argument &_e) {
3245 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
3246 return 0;
3247 }
3248 jresult = (void *)result;
3249 return jresult;
3250}
3251
3252
3253SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
3254 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3255 int arg2 ;
3256 operations_research::MPConstraint **arg3 = 0 ;
3257 operations_research::MPConstraint *temp3 = 0 ;
3258
3259 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3260 arg2 = (int)jarg2;
3261 temp3 = (operations_research::MPConstraint *)jarg3;
3262 arg3 = (operations_research::MPConstraint **)&temp3;
3263 try {
3264 std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Insert(arg1,arg2,(operations_research::MPConstraint *const &)*arg3);
3265 } catch(std::out_of_range &_e) {
3266 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3267 return ;
3268 }
3269}
3270
3271
3272SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
3273 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3274 int arg2 ;
3275 std::vector< operations_research::MPConstraint * > *arg3 = 0 ;
3276
3277 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3278 arg2 = (int)jarg2;
3279 arg3 = (std::vector< operations_research::MPConstraint * > *)jarg3;
3280 if (!arg3) {
3281 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::MPConstraint * > const & type is null", 0);
3282 return ;
3283 }
3284 try {
3285 std_vector_Sl_operations_research_MPConstraint_Sm__Sg__InsertRange(arg1,arg2,(std::vector< operations_research::MPConstraint * > const &)*arg3);
3286 } catch(std::out_of_range &_e) {
3287 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3288 return ;
3289 }
3290}
3291
3292
3293SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_RemoveAt___(void * jarg1, int jarg2) {
3294 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3295 int arg2 ;
3296
3297 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3298 arg2 = (int)jarg2;
3299 try {
3300 std_vector_Sl_operations_research_MPConstraint_Sm__Sg__RemoveAt(arg1,arg2);
3301 } catch(std::out_of_range &_e) {
3302 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3303 return ;
3304 }
3305}
3306
3307
3308SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
3309 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3310 int arg2 ;
3311 int arg3 ;
3312
3313 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3314 arg2 = (int)jarg2;
3315 arg3 = (int)jarg3;
3316 try {
3317 std_vector_Sl_operations_research_MPConstraint_Sm__Sg__RemoveRange(arg1,arg2,arg3);
3318 } catch(std::out_of_range &_e) {
3319 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3320 return ;
3321 } catch(std::invalid_argument &_e) {
3322 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
3323 return ;
3324 }
3325}
3326
3327
3328SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Repeat___(void * jarg1, int jarg2) {
3329 void * jresult ;
3330 operations_research::MPConstraint **arg1 = 0 ;
3331 int arg2 ;
3332 operations_research::MPConstraint *temp1 = 0 ;
3333 std::vector< operations_research::MPConstraint * > *result = 0 ;
3334
3335 temp1 = (operations_research::MPConstraint *)jarg1;
3336 arg1 = (operations_research::MPConstraint **)&temp1;
3337 arg2 = (int)jarg2;
3338 try {
3339 result = (std::vector< operations_research::MPConstraint * > *)std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Repeat((operations_research::MPConstraint *const &)*arg1,arg2);
3340 } catch(std::out_of_range &_e) {
3341 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3342 return 0;
3343 }
3344 jresult = (void *)result;
3345 return jresult;
3346}
3347
3348
3349SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Reverse__SWIG_0___(void * jarg1) {
3350 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3351
3352 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3353 std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Reverse__SWIG_0(arg1);
3354}
3355
3356
3357SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
3358 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3359 int arg2 ;
3360 int arg3 ;
3361
3362 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3363 arg2 = (int)jarg2;
3364 arg3 = (int)jarg3;
3365 try {
3366 std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
3367 } catch(std::out_of_range &_e) {
3368 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3369 return ;
3370 } catch(std::invalid_argument &_e) {
3371 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
3372 return ;
3373 }
3374}
3375
3376
3377SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
3378 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3379 int arg2 ;
3380 std::vector< operations_research::MPConstraint * > *arg3 = 0 ;
3381
3382 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3383 arg2 = (int)jarg2;
3384 arg3 = (std::vector< operations_research::MPConstraint * > *)jarg3;
3385 if (!arg3) {
3386 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::MPConstraint * > const & type is null", 0);
3387 return ;
3388 }
3389 try {
3390 std_vector_Sl_operations_research_MPConstraint_Sm__Sg__SetRange(arg1,arg2,(std::vector< operations_research::MPConstraint * > const &)*arg3);
3391 } catch(std::out_of_range &_e) {
3392 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3393 return ;
3394 }
3395}
3396
3397
3398SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Contains___(void * jarg1, void * jarg2) {
3399 unsigned int jresult ;
3400 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3401 operations_research::MPConstraint **arg2 = 0 ;
3402 operations_research::MPConstraint *temp2 = 0 ;
3403 bool result;
3404
3405 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3406 temp2 = (operations_research::MPConstraint *)jarg2;
3407 arg2 = (operations_research::MPConstraint **)&temp2;
3408 result = (bool)std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Contains(arg1,(operations_research::MPConstraint *const &)*arg2);
3409 jresult = result;
3410 return jresult;
3411}
3412
3413
3414SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_IndexOf___(void * jarg1, void * jarg2) {
3415 int jresult ;
3416 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3417 operations_research::MPConstraint **arg2 = 0 ;
3418 operations_research::MPConstraint *temp2 = 0 ;
3419 int result;
3420
3421 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3422 temp2 = (operations_research::MPConstraint *)jarg2;
3423 arg2 = (operations_research::MPConstraint **)&temp2;
3424 result = (int)std_vector_Sl_operations_research_MPConstraint_Sm__Sg__IndexOf(arg1,(operations_research::MPConstraint *const &)*arg2);
3425 jresult = result;
3426 return jresult;
3427}
3428
3429
3430SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_LastIndexOf___(void * jarg1, void * jarg2) {
3431 int jresult ;
3432 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3433 operations_research::MPConstraint **arg2 = 0 ;
3434 operations_research::MPConstraint *temp2 = 0 ;
3435 int result;
3436
3437 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3438 temp2 = (operations_research::MPConstraint *)jarg2;
3439 arg2 = (operations_research::MPConstraint **)&temp2;
3440 result = (int)std_vector_Sl_operations_research_MPConstraint_Sm__Sg__LastIndexOf(arg1,(operations_research::MPConstraint *const &)*arg2);
3441 jresult = result;
3442 return jresult;
3443}
3444
3445
3446SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Remove___(void * jarg1, void * jarg2) {
3447 unsigned int jresult ;
3448 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3449 operations_research::MPConstraint **arg2 = 0 ;
3450 operations_research::MPConstraint *temp2 = 0 ;
3451 bool result;
3452
3453 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3454 temp2 = (operations_research::MPConstraint *)jarg2;
3455 arg2 = (operations_research::MPConstraint **)&temp2;
3456 result = (bool)std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Remove(arg1,(operations_research::MPConstraint *const &)*arg2);
3457 jresult = result;
3458 return jresult;
3459}
3460
3461
3462SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_MPConstraintVector___(void * jarg1) {
3463 std::vector< operations_research::MPConstraint * > *arg1 = (std::vector< operations_research::MPConstraint * > *) 0 ;
3464
3465 arg1 = (std::vector< operations_research::MPConstraint * > *)jarg1;
3466 delete arg1;
3467}
3468
3469
3470SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Clear___(void * jarg1) {
3471 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3472
3473 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3474 (arg1)->clear();
3475}
3476
3477
3478SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Add___(void * jarg1, void * jarg2) {
3479 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3480 operations_research::MPVariable **arg2 = 0 ;
3481 operations_research::MPVariable *temp2 = 0 ;
3482
3483 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3484 temp2 = (operations_research::MPVariable *)jarg2;
3485 arg2 = (operations_research::MPVariable **)&temp2;
3486 (arg1)->push_back((operations_research::MPVariable *const &)*arg2);
3487}
3488
3489
3490SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_size___(void * jarg1) {
3491 unsigned long jresult ;
3492 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3493 std::vector< operations_research::MPVariable * >::size_type result;
3494
3495 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3496 result = ((std::vector< operations_research::MPVariable * > const *)arg1)->size();
3497 jresult = (unsigned long)result;
3498 return jresult;
3499}
3500
3501
3502SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_capacity___(void * jarg1) {
3503 unsigned long jresult ;
3504 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3505 std::vector< operations_research::MPVariable * >::size_type result;
3506
3507 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3508 result = ((std::vector< operations_research::MPVariable * > const *)arg1)->capacity();
3509 jresult = (unsigned long)result;
3510 return jresult;
3511}
3512
3513
3514SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_reserve___(void * jarg1, unsigned long jarg2) {
3515 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3516 std::vector< operations_research::MPVariable * >::size_type arg2 ;
3517
3518 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3519 arg2 = (std::vector< operations_research::MPVariable * >::size_type)jarg2;
3520 (arg1)->reserve(arg2);
3521}
3522
3523
3524SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPVariableVector__SWIG_0___() {
3525 void * jresult ;
3526 std::vector< operations_research::MPVariable * > *result = 0 ;
3527
3528 result = (std::vector< operations_research::MPVariable * > *)new std::vector< operations_research::MPVariable * >();
3529 jresult = (void *)result;
3530 return jresult;
3531}
3532
3533
3534SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPVariableVector__SWIG_1___(void * jarg1) {
3535 void * jresult ;
3536 std::vector< operations_research::MPVariable * > *arg1 = 0 ;
3537 std::vector< operations_research::MPVariable * > *result = 0 ;
3538
3539 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3540 if (!arg1) {
3541 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::MPVariable * > const & type is null", 0);
3542 return 0;
3543 }
3544 result = (std::vector< operations_research::MPVariable * > *)new std::vector< operations_research::MPVariable * >((std::vector< operations_research::MPVariable * > const &)*arg1);
3545 jresult = (void *)result;
3546 return jresult;
3547}
3548
3549
3550SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPVariableVector__SWIG_2___(int jarg1) {
3551 void * jresult ;
3552 int arg1 ;
3553 std::vector< operations_research::MPVariable * > *result = 0 ;
3554
3555 arg1 = (int)jarg1;
3556 try {
3557 result = (std::vector< operations_research::MPVariable * > *)new_std_vector_Sl_operations_research_MPVariable_Sm__Sg___SWIG_2(arg1);
3558 } catch(std::out_of_range &_e) {
3559 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3560 return 0;
3561 }
3562 jresult = (void *)result;
3563 return jresult;
3564}
3565
3566
3567SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_getitemcopy___(void * jarg1, int jarg2) {
3568 void * jresult ;
3569 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3570 int arg2 ;
3571 operations_research::MPVariable *result = 0 ;
3572
3573 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3574 arg2 = (int)jarg2;
3575 try {
3576 result = (operations_research::MPVariable *)std_vector_Sl_operations_research_MPVariable_Sm__Sg__getitemcopy(arg1,arg2);
3577 } catch(std::out_of_range &_e) {
3578 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3579 return 0;
3580 }
3581 jresult = (void *)result;
3582 return jresult;
3583}
3584
3585
3586SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_getitem___(void * jarg1, int jarg2) {
3587 void * jresult ;
3588 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3589 int arg2 ;
3590 std::vector< operations_research::MPVariable * >::value_type *result = 0 ;
3591
3592 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3593 arg2 = (int)jarg2;
3594 try {
3595 result = (std::vector< operations_research::MPVariable * >::value_type *) &std_vector_Sl_operations_research_MPVariable_Sm__Sg__getitem(arg1,arg2);
3596 } catch(std::out_of_range &_e) {
3597 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3598 return 0;
3599 }
3600 jresult = (void *)*result;
3601 return jresult;
3602}
3603
3604
3605SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
3606 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3607 int arg2 ;
3608 operations_research::MPVariable **arg3 = 0 ;
3609 operations_research::MPVariable *temp3 = 0 ;
3610
3611 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3612 arg2 = (int)jarg2;
3613 temp3 = (operations_research::MPVariable *)jarg3;
3614 arg3 = (operations_research::MPVariable **)&temp3;
3615 try {
3616 std_vector_Sl_operations_research_MPVariable_Sm__Sg__setitem(arg1,arg2,(operations_research::MPVariable *const &)*arg3);
3617 } catch(std::out_of_range &_e) {
3618 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3619 return ;
3620 }
3621}
3622
3623
3624SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_AddRange___(void * jarg1, void * jarg2) {
3625 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3626 std::vector< operations_research::MPVariable * > *arg2 = 0 ;
3627
3628 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3629 arg2 = (std::vector< operations_research::MPVariable * > *)jarg2;
3630 if (!arg2) {
3631 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::MPVariable * > const & type is null", 0);
3632 return ;
3633 }
3634 std_vector_Sl_operations_research_MPVariable_Sm__Sg__AddRange(arg1,(std::vector< operations_research::MPVariable * > const &)*arg2);
3635}
3636
3637
3638SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
3639 void * jresult ;
3640 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3641 int arg2 ;
3642 int arg3 ;
3643 std::vector< operations_research::MPVariable * > *result = 0 ;
3644
3645 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3646 arg2 = (int)jarg2;
3647 arg3 = (int)jarg3;
3648 try {
3649 result = (std::vector< operations_research::MPVariable * > *)std_vector_Sl_operations_research_MPVariable_Sm__Sg__GetRange(arg1,arg2,arg3);
3650 } catch(std::out_of_range &_e) {
3651 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3652 return 0;
3653 } catch(std::invalid_argument &_e) {
3654 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
3655 return 0;
3656 }
3657 jresult = (void *)result;
3658 return jresult;
3659}
3660
3661
3662SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
3663 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3664 int arg2 ;
3665 operations_research::MPVariable **arg3 = 0 ;
3666 operations_research::MPVariable *temp3 = 0 ;
3667
3668 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3669 arg2 = (int)jarg2;
3670 temp3 = (operations_research::MPVariable *)jarg3;
3671 arg3 = (operations_research::MPVariable **)&temp3;
3672 try {
3673 std_vector_Sl_operations_research_MPVariable_Sm__Sg__Insert(arg1,arg2,(operations_research::MPVariable *const &)*arg3);
3674 } catch(std::out_of_range &_e) {
3675 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3676 return ;
3677 }
3678}
3679
3680
3681SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
3682 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3683 int arg2 ;
3684 std::vector< operations_research::MPVariable * > *arg3 = 0 ;
3685
3686 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3687 arg2 = (int)jarg2;
3688 arg3 = (std::vector< operations_research::MPVariable * > *)jarg3;
3689 if (!arg3) {
3690 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::MPVariable * > const & type is null", 0);
3691 return ;
3692 }
3693 try {
3694 std_vector_Sl_operations_research_MPVariable_Sm__Sg__InsertRange(arg1,arg2,(std::vector< operations_research::MPVariable * > const &)*arg3);
3695 } catch(std::out_of_range &_e) {
3696 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3697 return ;
3698 }
3699}
3700
3701
3702SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_RemoveAt___(void * jarg1, int jarg2) {
3703 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3704 int arg2 ;
3705
3706 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3707 arg2 = (int)jarg2;
3708 try {
3709 std_vector_Sl_operations_research_MPVariable_Sm__Sg__RemoveAt(arg1,arg2);
3710 } catch(std::out_of_range &_e) {
3711 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3712 return ;
3713 }
3714}
3715
3716
3717SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
3718 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3719 int arg2 ;
3720 int arg3 ;
3721
3722 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3723 arg2 = (int)jarg2;
3724 arg3 = (int)jarg3;
3725 try {
3726 std_vector_Sl_operations_research_MPVariable_Sm__Sg__RemoveRange(arg1,arg2,arg3);
3727 } catch(std::out_of_range &_e) {
3728 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3729 return ;
3730 } catch(std::invalid_argument &_e) {
3731 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
3732 return ;
3733 }
3734}
3735
3736
3737SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Repeat___(void * jarg1, int jarg2) {
3738 void * jresult ;
3739 operations_research::MPVariable **arg1 = 0 ;
3740 int arg2 ;
3741 operations_research::MPVariable *temp1 = 0 ;
3742 std::vector< operations_research::MPVariable * > *result = 0 ;
3743
3744 temp1 = (operations_research::MPVariable *)jarg1;
3745 arg1 = (operations_research::MPVariable **)&temp1;
3746 arg2 = (int)jarg2;
3747 try {
3748 result = (std::vector< operations_research::MPVariable * > *)std_vector_Sl_operations_research_MPVariable_Sm__Sg__Repeat((operations_research::MPVariable *const &)*arg1,arg2);
3749 } catch(std::out_of_range &_e) {
3750 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3751 return 0;
3752 }
3753 jresult = (void *)result;
3754 return jresult;
3755}
3756
3757
3758SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Reverse__SWIG_0___(void * jarg1) {
3759 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3760
3761 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3762 std_vector_Sl_operations_research_MPVariable_Sm__Sg__Reverse__SWIG_0(arg1);
3763}
3764
3765
3766SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
3767 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3768 int arg2 ;
3769 int arg3 ;
3770
3771 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3772 arg2 = (int)jarg2;
3773 arg3 = (int)jarg3;
3774 try {
3775 std_vector_Sl_operations_research_MPVariable_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
3776 } catch(std::out_of_range &_e) {
3777 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3778 return ;
3779 } catch(std::invalid_argument &_e) {
3780 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
3781 return ;
3782 }
3783}
3784
3785
3786SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
3787 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3788 int arg2 ;
3789 std::vector< operations_research::MPVariable * > *arg3 = 0 ;
3790
3791 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3792 arg2 = (int)jarg2;
3793 arg3 = (std::vector< operations_research::MPVariable * > *)jarg3;
3794 if (!arg3) {
3795 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::MPVariable * > const & type is null", 0);
3796 return ;
3797 }
3798 try {
3799 std_vector_Sl_operations_research_MPVariable_Sm__Sg__SetRange(arg1,arg2,(std::vector< operations_research::MPVariable * > const &)*arg3);
3800 } catch(std::out_of_range &_e) {
3801 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
3802 return ;
3803 }
3804}
3805
3806
3807SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Contains___(void * jarg1, void * jarg2) {
3808 unsigned int jresult ;
3809 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3810 operations_research::MPVariable **arg2 = 0 ;
3811 operations_research::MPVariable *temp2 = 0 ;
3812 bool result;
3813
3814 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3815 temp2 = (operations_research::MPVariable *)jarg2;
3816 arg2 = (operations_research::MPVariable **)&temp2;
3817 result = (bool)std_vector_Sl_operations_research_MPVariable_Sm__Sg__Contains(arg1,(operations_research::MPVariable *const &)*arg2);
3818 jresult = result;
3819 return jresult;
3820}
3821
3822
3823SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_IndexOf___(void * jarg1, void * jarg2) {
3824 int jresult ;
3825 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3826 operations_research::MPVariable **arg2 = 0 ;
3827 operations_research::MPVariable *temp2 = 0 ;
3828 int result;
3829
3830 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3831 temp2 = (operations_research::MPVariable *)jarg2;
3832 arg2 = (operations_research::MPVariable **)&temp2;
3833 result = (int)std_vector_Sl_operations_research_MPVariable_Sm__Sg__IndexOf(arg1,(operations_research::MPVariable *const &)*arg2);
3834 jresult = result;
3835 return jresult;
3836}
3837
3838
3839SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_LastIndexOf___(void * jarg1, void * jarg2) {
3840 int jresult ;
3841 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3842 operations_research::MPVariable **arg2 = 0 ;
3843 operations_research::MPVariable *temp2 = 0 ;
3844 int result;
3845
3846 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3847 temp2 = (operations_research::MPVariable *)jarg2;
3848 arg2 = (operations_research::MPVariable **)&temp2;
3849 result = (int)std_vector_Sl_operations_research_MPVariable_Sm__Sg__LastIndexOf(arg1,(operations_research::MPVariable *const &)*arg2);
3850 jresult = result;
3851 return jresult;
3852}
3853
3854
3855SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Remove___(void * jarg1, void * jarg2) {
3856 unsigned int jresult ;
3857 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3858 operations_research::MPVariable **arg2 = 0 ;
3859 operations_research::MPVariable *temp2 = 0 ;
3860 bool result;
3861
3862 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3863 temp2 = (operations_research::MPVariable *)jarg2;
3864 arg2 = (operations_research::MPVariable **)&temp2;
3865 result = (bool)std_vector_Sl_operations_research_MPVariable_Sm__Sg__Remove(arg1,(operations_research::MPVariable *const &)*arg2);
3866 jresult = result;
3867 return jresult;
3868}
3869
3870
3871SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_MPVariableVector___(void * jarg1) {
3872 std::vector< operations_research::MPVariable * > *arg1 = (std::vector< operations_research::MPVariable * > *) 0 ;
3873
3874 arg1 = (std::vector< operations_research::MPVariable * > *)jarg1;
3875 delete arg1;
3876}
3877
3878
3879SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Solver___(char * jarg1, int jarg2) {
3880 void * jresult ;
3881 std::string *arg1 = 0 ;
3882 operations_research::MPSolver::OptimizationProblemType arg2 ;
3883 operations_research::MPSolver *result = 0 ;
3884
3885 if (!jarg1) {
3886 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
3887 return 0;
3888 }
3889 std::string arg1_str(jarg1);
3890 arg1 = &arg1_str;
3891 arg2 = (operations_research::MPSolver::OptimizationProblemType)jarg2;
3892 result = (operations_research::MPSolver *)new operations_research::MPSolver((std::string const &)*arg1,arg2);
3893 jresult = (void *)result;
3894 return jresult;
3895}
3896
3897
3898SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Solver___(void * jarg1) {
3899 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
3900
3901 arg1 = (operations_research::MPSolver *)jarg1;
3902 delete arg1;
3903}
3904
3905
3906SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_CreateSolver___(char * jarg1) {
3907 void * jresult ;
3908 std::string *arg1 = 0 ;
3909 operations_research::MPSolver *result = 0 ;
3910
3911 if (!jarg1) {
3912 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
3913 return 0;
3914 }
3915 std::string arg1_str(jarg1);
3916 arg1 = &arg1_str;
3917 result = (operations_research::MPSolver *)operations_research::MPSolver::CreateSolver((std::string const &)*arg1);
3918 jresult = (void *)result;
3919 return jresult;
3920}
3921
3922
3923SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SupportsProblemType___(int jarg1) {
3924 unsigned int jresult ;
3925 operations_research::MPSolver::OptimizationProblemType arg1 ;
3926 bool result;
3927
3928 arg1 = (operations_research::MPSolver::OptimizationProblemType)jarg1;
3929 result = (bool)operations_research::MPSolver::SupportsProblemType(arg1);
3930 jresult = result;
3931 return jresult;
3932}
3933
3934
3935SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Clear___(void * jarg1) {
3936 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
3937
3938 arg1 = (operations_research::MPSolver *)jarg1;
3939 (arg1)->Clear();
3940}
3941
3942
3943SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_NumVariables___(void * jarg1) {
3944 int jresult ;
3945 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
3946 int result;
3947
3948 arg1 = (operations_research::MPSolver *)jarg1;
3949 result = (int)((operations_research::MPSolver const *)arg1)->NumVariables();
3950 jresult = result;
3951 return jresult;
3952}
3953
3954
3955SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_variables___(void * jarg1) {
3956 void * jresult ;
3957 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
3958 std::vector< operations_research::MPVariable * > *result = 0 ;
3959
3960 arg1 = (operations_research::MPSolver *)jarg1;
3961 result = (std::vector< operations_research::MPVariable * > *) &((operations_research::MPSolver const *)arg1)->variables();
3962 jresult = (void *)result;
3963 return jresult;
3964}
3965
3966
3967SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Variable___(void * jarg1, int jarg2) {
3968 void * jresult ;
3969 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
3970 int arg2 ;
3971 operations_research::MPVariable *result = 0 ;
3972
3973 arg1 = (operations_research::MPSolver *)jarg1;
3974 arg2 = (int)jarg2;
3975 result = (operations_research::MPVariable *)((operations_research::MPSolver const *)arg1)->variable(arg2);
3976 jresult = (void *)result;
3977 return jresult;
3978}
3979
3980
3981SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_LookupVariableOrNull___(void * jarg1, char * jarg2) {
3982 void * jresult ;
3983 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
3984 std::string *arg2 = 0 ;
3985 operations_research::MPVariable *result = 0 ;
3986
3987 arg1 = (operations_research::MPSolver *)jarg1;
3988 if (!jarg2) {
3989 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
3990 return 0;
3991 }
3992 std::string arg2_str(jarg2);
3993 arg2 = &arg2_str;
3994 result = (operations_research::MPVariable *)((operations_research::MPSolver const *)arg1)->LookupVariableOrNull((std::string const &)*arg2);
3995 jresult = (void *)result;
3996 return jresult;
3997}
3998
3999
4000SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeVar___(void * jarg1, double jarg2, double jarg3, unsigned int jarg4, char * jarg5) {
4001 void * jresult ;
4002 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4003 double arg2 ;
4004 double arg3 ;
4005 bool arg4 ;
4006 std::string *arg5 = 0 ;
4007 operations_research::MPVariable *result = 0 ;
4008
4009 arg1 = (operations_research::MPSolver *)jarg1;
4010 arg2 = (double)jarg2;
4011 arg3 = (double)jarg3;
4012 arg4 = jarg4 ? true : false;
4013 if (!jarg5) {
4014 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
4015 return 0;
4016 }
4017 std::string arg5_str(jarg5);
4018 arg5 = &arg5_str;
4019 result = (operations_research::MPVariable *)(arg1)->MakeVar(arg2,arg3,arg4,(std::string const &)*arg5);
4020 jresult = (void *)result;
4021 return jresult;
4022}
4023
4024
4025SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeNumVar___(void * jarg1, double jarg2, double jarg3, char * jarg4) {
4026 void * jresult ;
4027 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4028 double arg2 ;
4029 double arg3 ;
4030 std::string *arg4 = 0 ;
4031 operations_research::MPVariable *result = 0 ;
4032
4033 arg1 = (operations_research::MPSolver *)jarg1;
4034 arg2 = (double)jarg2;
4035 arg3 = (double)jarg3;
4036 if (!jarg4) {
4037 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
4038 return 0;
4039 }
4040 std::string arg4_str(jarg4);
4041 arg4 = &arg4_str;
4042 result = (operations_research::MPVariable *)(arg1)->MakeNumVar(arg2,arg3,(std::string const &)*arg4);
4043 jresult = (void *)result;
4044 return jresult;
4045}
4046
4047
4048SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeIntVar___(void * jarg1, double jarg2, double jarg3, char * jarg4) {
4049 void * jresult ;
4050 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4051 double arg2 ;
4052 double arg3 ;
4053 std::string *arg4 = 0 ;
4054 operations_research::MPVariable *result = 0 ;
4055
4056 arg1 = (operations_research::MPSolver *)jarg1;
4057 arg2 = (double)jarg2;
4058 arg3 = (double)jarg3;
4059 if (!jarg4) {
4060 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
4061 return 0;
4062 }
4063 std::string arg4_str(jarg4);
4064 arg4 = &arg4_str;
4065 result = (operations_research::MPVariable *)(arg1)->MakeIntVar(arg2,arg3,(std::string const &)*arg4);
4066 jresult = (void *)result;
4067 return jresult;
4068}
4069
4070
4071SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeBoolVar___(void * jarg1, char * jarg2) {
4072 void * jresult ;
4073 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4074 std::string *arg2 = 0 ;
4075 operations_research::MPVariable *result = 0 ;
4076
4077 arg1 = (operations_research::MPSolver *)jarg1;
4078 if (!jarg2) {
4079 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
4080 return 0;
4081 }
4082 std::string arg2_str(jarg2);
4083 arg2 = &arg2_str;
4084 result = (operations_research::MPVariable *)(arg1)->MakeBoolVar((std::string const &)*arg2);
4085 jresult = (void *)result;
4086 return jresult;
4087}
4088
4089
4090SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_NumConstraints___(void * jarg1) {
4091 int jresult ;
4092 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4093 int result;
4094
4095 arg1 = (operations_research::MPSolver *)jarg1;
4096 result = (int)((operations_research::MPSolver const *)arg1)->NumConstraints();
4097 jresult = result;
4098 return jresult;
4099}
4100
4101
4102SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_constraints___(void * jarg1) {
4103 void * jresult ;
4104 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4105 std::vector< operations_research::MPConstraint * > *result = 0 ;
4106
4107 arg1 = (operations_research::MPSolver *)jarg1;
4108 result = (std::vector< operations_research::MPConstraint * > *) &((operations_research::MPSolver const *)arg1)->constraints();
4109 jresult = (void *)result;
4110 return jresult;
4111}
4112
4113
4114SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Constraint___(void * jarg1, int jarg2) {
4115 void * jresult ;
4116 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4117 int arg2 ;
4118 operations_research::MPConstraint *result = 0 ;
4119
4120 arg1 = (operations_research::MPSolver *)jarg1;
4121 arg2 = (int)jarg2;
4122 result = (operations_research::MPConstraint *)((operations_research::MPSolver const *)arg1)->constraint(arg2);
4123 jresult = (void *)result;
4124 return jresult;
4125}
4126
4127
4128SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_LookupConstraintOrNull___(void * jarg1, char * jarg2) {
4129 void * jresult ;
4130 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4131 std::string *arg2 = 0 ;
4132 operations_research::MPConstraint *result = 0 ;
4133
4134 arg1 = (operations_research::MPSolver *)jarg1;
4135 if (!jarg2) {
4136 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
4137 return 0;
4138 }
4139 std::string arg2_str(jarg2);
4140 arg2 = &arg2_str;
4141 result = (operations_research::MPConstraint *)((operations_research::MPSolver const *)arg1)->LookupConstraintOrNull((std::string const &)*arg2);
4142 jresult = (void *)result;
4143 return jresult;
4144}
4145
4146
4147SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_0___(void * jarg1, double jarg2, double jarg3) {
4148 void * jresult ;
4149 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4150 double arg2 ;
4151 double arg3 ;
4152 operations_research::MPConstraint *result = 0 ;
4153
4154 arg1 = (operations_research::MPSolver *)jarg1;
4155 arg2 = (double)jarg2;
4156 arg3 = (double)jarg3;
4157 result = (operations_research::MPConstraint *)(arg1)->MakeRowConstraint(arg2,arg3);
4158 jresult = (void *)result;
4159 return jresult;
4160}
4161
4162
4163SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_1___(void * jarg1) {
4164 void * jresult ;
4165 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4166 operations_research::MPConstraint *result = 0 ;
4167
4168 arg1 = (operations_research::MPSolver *)jarg1;
4169 result = (operations_research::MPConstraint *)(arg1)->MakeRowConstraint();
4170 jresult = (void *)result;
4171 return jresult;
4172}
4173
4174
4175SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_2___(void * jarg1, double jarg2, double jarg3, char * jarg4) {
4176 void * jresult ;
4177 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4178 double arg2 ;
4179 double arg3 ;
4180 std::string *arg4 = 0 ;
4181 operations_research::MPConstraint *result = 0 ;
4182
4183 arg1 = (operations_research::MPSolver *)jarg1;
4184 arg2 = (double)jarg2;
4185 arg3 = (double)jarg3;
4186 if (!jarg4) {
4187 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
4188 return 0;
4189 }
4190 std::string arg4_str(jarg4);
4191 arg4 = &arg4_str;
4192 result = (operations_research::MPConstraint *)(arg1)->MakeRowConstraint(arg2,arg3,(std::string const &)*arg4);
4193 jresult = (void *)result;
4194 return jresult;
4195}
4196
4197
4198SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_3___(void * jarg1, char * jarg2) {
4199 void * jresult ;
4200 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4201 std::string *arg2 = 0 ;
4202 operations_research::MPConstraint *result = 0 ;
4203
4204 arg1 = (operations_research::MPSolver *)jarg1;
4205 if (!jarg2) {
4206 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
4207 return 0;
4208 }
4209 std::string arg2_str(jarg2);
4210 arg2 = &arg2_str;
4211 result = (operations_research::MPConstraint *)(arg1)->MakeRowConstraint((std::string const &)*arg2);
4212 jresult = (void *)result;
4213 return jresult;
4214}
4215
4216
4217SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Objective___(void * jarg1) {
4218 void * jresult ;
4219 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4220 operations_research::MPObjective *result = 0 ;
4221
4222 arg1 = (operations_research::MPSolver *)jarg1;
4223 result = (operations_research::MPObjective *)(arg1)->MutableObjective();
4224 jresult = (void *)result;
4225 return jresult;
4226}
4227
4228
4229SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Solve__SWIG_0___(void * jarg1) {
4230 int jresult ;
4231 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4232 operations_research::MPSolver::ResultStatus result;
4233
4234 arg1 = (operations_research::MPSolver *)jarg1;
4235 result = (operations_research::MPSolver::ResultStatus)(arg1)->Solve();
4236 jresult = (int)result;
4237 return jresult;
4238}
4239
4240
4241SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Solve__SWIG_1___(void * jarg1, void * jarg2) {
4242 int jresult ;
4243 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4244 operations_research::MPSolverParameters *arg2 = 0 ;
4245 operations_research::MPSolver::ResultStatus result;
4246
4247 arg1 = (operations_research::MPSolver *)jarg1;
4248 arg2 = (operations_research::MPSolverParameters *)jarg2;
4249 if (!arg2) {
4250 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::MPSolverParameters const & type is null", 0);
4251 return 0;
4252 }
4253 result = (operations_research::MPSolver::ResultStatus)(arg1)->Solve((operations_research::MPSolverParameters const &)*arg2);
4254 jresult = (int)result;
4255 return jresult;
4256}
4257
4258
4259SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_ComputeConstraintActivities___(void * jarg1) {
4260 void* jresult ;
4261 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4262 std::vector< double > result;
4263
4264 arg1 = (operations_research::MPSolver *)jarg1;
4265 result = ((operations_research::MPSolver const *)arg1)->ComputeConstraintActivities();
4266
4267 jresult = new std::vector< double >((const std::vector< double> &)result);
4268
4269 return jresult;
4270}
4271
4272
4273SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_VerifySolution___(void * jarg1, double jarg2, unsigned int jarg3) {
4274 unsigned int jresult ;
4275 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4276 double arg2 ;
4277 bool arg3 ;
4278 bool result;
4279
4280 arg1 = (operations_research::MPSolver *)jarg1;
4281 arg2 = (double)jarg2;
4282 arg3 = jarg3 ? true : false;
4283 result = (bool)((operations_research::MPSolver const *)arg1)->VerifySolution(arg2,arg3);
4284 jresult = result;
4285 return jresult;
4286}
4287
4288
4289SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Reset___(void * jarg1) {
4290 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4291
4292 arg1 = (operations_research::MPSolver *)jarg1;
4293 (arg1)->Reset();
4294}
4295
4296
4297SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_InterruptSolve___(void * jarg1) {
4298 unsigned int jresult ;
4299 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4300 bool result;
4301
4302 arg1 = (operations_research::MPSolver *)jarg1;
4303 result = (bool)(arg1)->InterruptSolve();
4304 jresult = result;
4305 return jresult;
4306}
4307
4308
4309SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SetSolverSpecificParametersAsString___(void * jarg1, char * jarg2) {
4310 unsigned int jresult ;
4311 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4312 std::string *arg2 = 0 ;
4313 bool result;
4314
4315 arg1 = (operations_research::MPSolver *)jarg1;
4316 if (!jarg2) {
4317 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
4318 return 0;
4319 }
4320 std::string arg2_str(jarg2);
4321 arg2 = &arg2_str;
4322 result = (bool)(arg1)->SetSolverSpecificParametersAsString((std::string const &)*arg2);
4323 jresult = result;
4324 return jresult;
4325}
4326
4327
4328SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_EnableOutput___(void * jarg1) {
4329 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4330
4331 arg1 = (operations_research::MPSolver *)jarg1;
4332 (arg1)->EnableOutput();
4333}
4334
4335
4336SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SuppressOutput___(void * jarg1) {
4337 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4338
4339 arg1 = (operations_research::MPSolver *)jarg1;
4340 (arg1)->SuppressOutput();
4341}
4342
4343
4344SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Iterations___(void * jarg1) {
4345 long long jresult ;
4346 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4347 int64_t result;
4348
4349 arg1 = (operations_research::MPSolver *)jarg1;
4350 result = (int64_t)((operations_research::MPSolver const *)arg1)->iterations();
4351 jresult = result;
4352 return jresult;
4353}
4354
4355
4356SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Nodes___(void * jarg1) {
4357 long long jresult ;
4358 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4359 int64_t result;
4360
4361 arg1 = (operations_research::MPSolver *)jarg1;
4362 result = (int64_t)((operations_research::MPSolver const *)arg1)->nodes();
4363 jresult = result;
4364 return jresult;
4365}
4366
4367
4368SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_ComputeExactConditionNumber___(void * jarg1) {
4369 double jresult ;
4370 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4371 double result;
4372
4373 arg1 = (operations_research::MPSolver *)jarg1;
4374 result = (double)((operations_research::MPSolver const *)arg1)->ComputeExactConditionNumber();
4375 jresult = result;
4376 return jresult;
4377}
4378
4379
4380SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SetTimeLimit___(void * jarg1, long long jarg2) {
4381 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4382 int64_t arg2 ;
4383
4384 arg1 = (operations_research::MPSolver *)jarg1;
4385 arg2 = (int64_t)jarg2;
4386 (arg1)->set_time_limit(arg2);
4387}
4388
4389
4390SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_WallTime___(void * jarg1) {
4391 long long jresult ;
4392 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4393 int64_t result;
4394
4395 arg1 = (operations_research::MPSolver *)jarg1;
4396 result = (int64_t)((operations_research::MPSolver const *)arg1)->wall_time();
4397 jresult = result;
4398 return jresult;
4399}
4400
4401
4402SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_ExportModelAsLpFormat___(void * jarg1, unsigned int jarg2) {
4403 char * jresult ;
4404 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4405 bool arg2 ;
4406 std::string result;
4407
4408 arg1 = (operations_research::MPSolver *)jarg1;
4409 arg2 = jarg2 ? true : false;
4410 result = operations_research_MPSolver_ExportModelAsLpFormat(arg1,arg2);
4411 jresult = SWIG_csharp_string_callback((&result)->c_str());
4412 return jresult;
4413}
4414
4415
4416SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_ExportModelAsMpsFormat___(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
4417 char * jresult ;
4418 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4419 bool arg2 ;
4420 bool arg3 ;
4421 std::string result;
4422
4423 arg1 = (operations_research::MPSolver *)jarg1;
4424 arg2 = jarg2 ? true : false;
4425 arg3 = jarg3 ? true : false;
4426 result = operations_research_MPSolver_ExportModelAsMpsFormat(arg1,arg2,arg3);
4427 jresult = SWIG_csharp_string_callback((&result)->c_str());
4428 return jresult;
4429}
4430
4431
4432SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SetHint___(void * jarg1, void * jarg2, int length3, double* jarg3) {
4433 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4434 std::vector< operations_research::MPVariable * > *arg2 = 0 ;
4435 std::vector< double > *arg3 = 0 ;
4436
4437 arg1 = (operations_research::MPSolver *)jarg1;
4438 arg2 = (std::vector< operations_research::MPVariable * > *)jarg2;
4439 if (!arg2) {
4440 SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::MPVariable * > const & type is null", 0);
4441 return ;
4442 }
4443
4444 arg3 = new std::vector<double>;
4445 arg3->reserve(length3);
4446 for(int i = 0; i < length3; ++i) {
4447 arg3->emplace_back(jarg3[i]);
4448 }
4449
4450 operations_research_MPSolver_SetHint(arg1,(std::vector< operations_research::MPVariable * > const &)*arg2,(std::vector< double > const &)*arg3);
4451 {
4452 delete arg3;
4453 }
4454}
4455
4456
4457SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SetNumThreads___(void * jarg1, int jarg2) {
4458 unsigned int jresult ;
4459 operations_research::MPSolver *arg1 = (operations_research::MPSolver *) 0 ;
4460 int arg2 ;
4461 bool result;
4462
4463 arg1 = (operations_research::MPSolver *)jarg1;
4464 arg2 = (int)jarg2;
4465 result = (bool)operations_research_MPSolver_SetNumThreads(arg1,arg2);
4466 jresult = result;
4467 return jresult;
4468}
4469
4470
4471SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_Clear___(void * jarg1) {
4472 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4473
4474 arg1 = (operations_research::MPObjective *)jarg1;
4475 (arg1)->Clear();
4476}
4477
4478
4479SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_SetCoefficient___(void * jarg1, void * jarg2, double jarg3) {
4480 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4481 operations_research::MPVariable *arg2 = (operations_research::MPVariable *) (operations_research::MPVariable *)0 ;
4482 double arg3 ;
4483
4484 arg1 = (operations_research::MPObjective *)jarg1;
4485 arg2 = (operations_research::MPVariable *)jarg2;
4486 arg3 = (double)jarg3;
4487 (arg1)->SetCoefficient((operations_research::MPVariable const *)arg2,arg3);
4488}
4489
4490
4491SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_GetCoefficient___(void * jarg1, void * jarg2) {
4492 double jresult ;
4493 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4494 operations_research::MPVariable *arg2 = (operations_research::MPVariable *) (operations_research::MPVariable *)0 ;
4495 double result;
4496
4497 arg1 = (operations_research::MPObjective *)jarg1;
4498 arg2 = (operations_research::MPVariable *)jarg2;
4499 result = (double)((operations_research::MPObjective const *)arg1)->GetCoefficient((operations_research::MPVariable const *)arg2);
4500 jresult = result;
4501 return jresult;
4502}
4503
4504
4505SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_SetOffset___(void * jarg1, double jarg2) {
4506 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4507 double arg2 ;
4508
4509 arg1 = (operations_research::MPObjective *)jarg1;
4510 arg2 = (double)jarg2;
4511 (arg1)->SetOffset(arg2);
4512}
4513
4514
4515SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_Offset___(void * jarg1) {
4516 double jresult ;
4517 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4518 double result;
4519
4520 arg1 = (operations_research::MPObjective *)jarg1;
4521 result = (double)((operations_research::MPObjective const *)arg1)->offset();
4522 jresult = result;
4523 return jresult;
4524}
4525
4526
4527SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_SetOptimizationDirection___(void * jarg1, unsigned int jarg2) {
4528 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4529 bool arg2 ;
4530
4531 arg1 = (operations_research::MPObjective *)jarg1;
4532 arg2 = jarg2 ? true : false;
4533 (arg1)->SetOptimizationDirection(arg2);
4534}
4535
4536
4537SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_SetMinimization___(void * jarg1) {
4538 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4539
4540 arg1 = (operations_research::MPObjective *)jarg1;
4541 (arg1)->SetMinimization();
4542}
4543
4544
4545SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_SetMaximization___(void * jarg1) {
4546 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4547
4548 arg1 = (operations_research::MPObjective *)jarg1;
4549 (arg1)->SetMaximization();
4550}
4551
4552
4553SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_Maximization___(void * jarg1) {
4554 unsigned int jresult ;
4555 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4556 bool result;
4557
4558 arg1 = (operations_research::MPObjective *)jarg1;
4559 result = (bool)((operations_research::MPObjective const *)arg1)->maximization();
4560 jresult = result;
4561 return jresult;
4562}
4563
4564
4565SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_Minimization___(void * jarg1) {
4566 unsigned int jresult ;
4567 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4568 bool result;
4569
4570 arg1 = (operations_research::MPObjective *)jarg1;
4571 result = (bool)((operations_research::MPObjective const *)arg1)->minimization();
4572 jresult = result;
4573 return jresult;
4574}
4575
4576
4577SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_Value___(void * jarg1) {
4578 double jresult ;
4579 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4580 double result;
4581
4582 arg1 = (operations_research::MPObjective *)jarg1;
4583 result = (double)((operations_research::MPObjective const *)arg1)->Value();
4584 jresult = result;
4585 return jresult;
4586}
4587
4588
4589SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_BestBound___(void * jarg1) {
4590 double jresult ;
4591 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4592 double result;
4593
4594 arg1 = (operations_research::MPObjective *)jarg1;
4595 result = (double)((operations_research::MPObjective const *)arg1)->BestBound();
4596 jresult = result;
4597 return jresult;
4598}
4599
4600
4601SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Objective___(void * jarg1) {
4602 operations_research::MPObjective *arg1 = (operations_research::MPObjective *) 0 ;
4603
4604 arg1 = (operations_research::MPObjective *)jarg1;
4605 delete arg1;
4606}
4607
4608
4609SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_Name___(void * jarg1) {
4610 char * jresult ;
4611 operations_research::MPVariable *arg1 = (operations_research::MPVariable *) 0 ;
4612 std::string *result = 0 ;
4613
4614 arg1 = (operations_research::MPVariable *)jarg1;
4615 result = (std::string *) &((operations_research::MPVariable const *)arg1)->name();
4616 jresult = SWIG_csharp_string_callback(result->c_str());
4617 return jresult;
4618}
4619
4620
4621SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_SetInteger___(void * jarg1, unsigned int jarg2) {
4622 operations_research::MPVariable *arg1 = (operations_research::MPVariable *) 0 ;
4623 bool arg2 ;
4624
4625 arg1 = (operations_research::MPVariable *)jarg1;
4626 arg2 = jarg2 ? true : false;
4627 (arg1)->SetInteger(arg2);
4628}
4629
4630
4631SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_SolutionValue___(void * jarg1) {
4632 double jresult ;
4633 operations_research::MPVariable *arg1 = (operations_research::MPVariable *) 0 ;
4634 double result;
4635
4636 arg1 = (operations_research::MPVariable *)jarg1;
4637 result = (double)((operations_research::MPVariable const *)arg1)->solution_value();
4638 jresult = result;
4639 return jresult;
4640}
4641
4642
4643SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_Lb___(void * jarg1) {
4644 double jresult ;
4645 operations_research::MPVariable *arg1 = (operations_research::MPVariable *) 0 ;
4646 double result;
4647
4648 arg1 = (operations_research::MPVariable *)jarg1;
4649 result = (double)((operations_research::MPVariable const *)arg1)->lb();
4650 jresult = result;
4651 return jresult;
4652}
4653
4654
4655SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_Ub___(void * jarg1) {
4656 double jresult ;
4657 operations_research::MPVariable *arg1 = (operations_research::MPVariable *) 0 ;
4658 double result;
4659
4660 arg1 = (operations_research::MPVariable *)jarg1;
4661 result = (double)((operations_research::MPVariable const *)arg1)->ub();
4662 jresult = result;
4663 return jresult;
4664}
4665
4666
4667SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_SetLb___(void * jarg1, double jarg2) {
4668 operations_research::MPVariable *arg1 = (operations_research::MPVariable *) 0 ;
4669 double arg2 ;
4670
4671 arg1 = (operations_research::MPVariable *)jarg1;
4672 arg2 = (double)jarg2;
4673 (arg1)->SetLB(arg2);
4674}
4675
4676
4677SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_SetUb___(void * jarg1, double jarg2) {
4678 operations_research::MPVariable *arg1 = (operations_research::MPVariable *) 0 ;
4679 double arg2 ;
4680
4681 arg1 = (operations_research::MPVariable *)jarg1;
4682 arg2 = (double)jarg2;
4683 (arg1)->SetUB(arg2);
4684}
4685
4686
4687SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_SetBounds___(void * jarg1, double jarg2, double jarg3) {
4688 operations_research::MPVariable *arg1 = (operations_research::MPVariable *) 0 ;
4689 double arg2 ;
4690 double arg3 ;
4691
4692 arg1 = (operations_research::MPVariable *)jarg1;
4693 arg2 = (double)jarg2;
4694 arg3 = (double)jarg3;
4695 (arg1)->SetBounds(arg2,arg3);
4696}
4697
4698
4699SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_ReducedCost___(void * jarg1) {
4700 double jresult ;
4701 operations_research::MPVariable *arg1 = (operations_research::MPVariable *) 0 ;
4702 double result;
4703
4704 arg1 = (operations_research::MPVariable *)jarg1;
4705 result = (double)((operations_research::MPVariable const *)arg1)->reduced_cost();
4706 jresult = result;
4707 return jresult;
4708}
4709
4710
4711SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_BasisStatus___(void * jarg1) {
4712 int jresult ;
4713 operations_research::MPVariable *arg1 = (operations_research::MPVariable *) 0 ;
4714 operations_research::MPSolver::BasisStatus result;
4715
4716 arg1 = (operations_research::MPVariable *)jarg1;
4717 result = (operations_research::MPSolver::BasisStatus)((operations_research::MPVariable const *)arg1)->basis_status();
4718 jresult = (int)result;
4719 return jresult;
4720}
4721
4722
4723SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Variable___(void * jarg1) {
4724 operations_research::MPVariable *arg1 = (operations_research::MPVariable *) 0 ;
4725
4726 arg1 = (operations_research::MPVariable *)jarg1;
4727 delete arg1;
4728}
4729
4730
4731SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_Name___(void * jarg1) {
4732 char * jresult ;
4733 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4734 std::string *result = 0 ;
4735
4736 arg1 = (operations_research::MPConstraint *)jarg1;
4737 result = (std::string *) &((operations_research::MPConstraint const *)arg1)->name();
4738 jresult = SWIG_csharp_string_callback(result->c_str());
4739 return jresult;
4740}
4741
4742
4743SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_SetCoefficient___(void * jarg1, void * jarg2, double jarg3) {
4744 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4745 operations_research::MPVariable *arg2 = (operations_research::MPVariable *) (operations_research::MPVariable *)0 ;
4746 double arg3 ;
4747
4748 arg1 = (operations_research::MPConstraint *)jarg1;
4749 arg2 = (operations_research::MPVariable *)jarg2;
4750 arg3 = (double)jarg3;
4751 (arg1)->SetCoefficient((operations_research::MPVariable const *)arg2,arg3);
4752}
4753
4754
4755SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_GetCoefficient___(void * jarg1, void * jarg2) {
4756 double jresult ;
4757 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4758 operations_research::MPVariable *arg2 = (operations_research::MPVariable *) (operations_research::MPVariable *)0 ;
4759 double result;
4760
4761 arg1 = (operations_research::MPConstraint *)jarg1;
4762 arg2 = (operations_research::MPVariable *)jarg2;
4763 result = (double)((operations_research::MPConstraint const *)arg1)->GetCoefficient((operations_research::MPVariable const *)arg2);
4764 jresult = result;
4765 return jresult;
4766}
4767
4768
4769SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_Lb___(void * jarg1) {
4770 double jresult ;
4771 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4772 double result;
4773
4774 arg1 = (operations_research::MPConstraint *)jarg1;
4775 result = (double)((operations_research::MPConstraint const *)arg1)->lb();
4776 jresult = result;
4777 return jresult;
4778}
4779
4780
4781SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_Ub___(void * jarg1) {
4782 double jresult ;
4783 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4784 double result;
4785
4786 arg1 = (operations_research::MPConstraint *)jarg1;
4787 result = (double)((operations_research::MPConstraint const *)arg1)->ub();
4788 jresult = result;
4789 return jresult;
4790}
4791
4792
4793SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_SetLb___(void * jarg1, double jarg2) {
4794 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4795 double arg2 ;
4796
4797 arg1 = (operations_research::MPConstraint *)jarg1;
4798 arg2 = (double)jarg2;
4799 (arg1)->SetLB(arg2);
4800}
4801
4802
4803SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_SetUb___(void * jarg1, double jarg2) {
4804 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4805 double arg2 ;
4806
4807 arg1 = (operations_research::MPConstraint *)jarg1;
4808 arg2 = (double)jarg2;
4809 (arg1)->SetUB(arg2);
4810}
4811
4812
4813SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_SetBounds___(void * jarg1, double jarg2, double jarg3) {
4814 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4815 double arg2 ;
4816 double arg3 ;
4817
4818 arg1 = (operations_research::MPConstraint *)jarg1;
4819 arg2 = (double)jarg2;
4820 arg3 = (double)jarg3;
4821 (arg1)->SetBounds(arg2,arg3);
4822}
4823
4824
4825SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_IsLazy___(void * jarg1) {
4826 unsigned int jresult ;
4827 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4828 bool result;
4829
4830 arg1 = (operations_research::MPConstraint *)jarg1;
4831 result = (bool)((operations_research::MPConstraint const *)arg1)->is_lazy();
4832 jresult = result;
4833 return jresult;
4834}
4835
4836
4837SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_SetIsLazy___(void * jarg1, unsigned int jarg2) {
4838 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4839 bool arg2 ;
4840
4841 arg1 = (operations_research::MPConstraint *)jarg1;
4842 arg2 = jarg2 ? true : false;
4843 (arg1)->set_is_lazy(arg2);
4844}
4845
4846
4847SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_Index___(void * jarg1) {
4848 int jresult ;
4849 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4850 int result;
4851
4852 arg1 = (operations_research::MPConstraint *)jarg1;
4853 result = (int)((operations_research::MPConstraint const *)arg1)->index();
4854 jresult = result;
4855 return jresult;
4856}
4857
4858
4859SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_DualValue___(void * jarg1) {
4860 double jresult ;
4861 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4862 double result;
4863
4864 arg1 = (operations_research::MPConstraint *)jarg1;
4865 result = (double)((operations_research::MPConstraint const *)arg1)->dual_value();
4866 jresult = result;
4867 return jresult;
4868}
4869
4870
4871SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_BasisStatus___(void * jarg1) {
4872 int jresult ;
4873 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4874 operations_research::MPSolver::BasisStatus result;
4875
4876 arg1 = (operations_research::MPConstraint *)jarg1;
4877 result = (operations_research::MPSolver::BasisStatus)((operations_research::MPConstraint const *)arg1)->basis_status();
4878 jresult = (int)result;
4879 return jresult;
4880}
4881
4882
4883SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Constraint___(void * jarg1) {
4884 operations_research::MPConstraint *arg1 = (operations_research::MPConstraint *) 0 ;
4885
4886 arg1 = (operations_research::MPConstraint *)jarg1;
4887 delete arg1;
4888}
4889
4890
4891SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultRelativeMipGap_get___() {
4892 double jresult ;
4893 double result;
4894
4895 result = (double)(double)operations_research::MPSolverParameters::kDefaultRelativeMipGap;
4896 jresult = result;
4897 return jresult;
4898}
4899
4900
4901SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultPrimalTolerance_get___() {
4902 double jresult ;
4903 double result;
4904
4905 result = (double)(double)operations_research::MPSolverParameters::kDefaultPrimalTolerance;
4906 jresult = result;
4907 return jresult;
4908}
4909
4910
4911SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultDualTolerance_get___() {
4912 double jresult ;
4913 double result;
4914
4915 result = (double)(double)operations_research::MPSolverParameters::kDefaultDualTolerance;
4916 jresult = result;
4917 return jresult;
4918}
4919
4920
4921SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultPresolve_get___() {
4922 int jresult ;
4923 operations_research::MPSolverParameters::PresolveValues result;
4924
4925 result = (operations_research::MPSolverParameters::PresolveValues)(operations_research::MPSolverParameters::PresolveValues)operations_research::MPSolverParameters::kDefaultPresolve;
4926 jresult = (int)result;
4927 return jresult;
4928}
4929
4930
4931SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultIncrementality_get___() {
4932 int jresult ;
4933 operations_research::MPSolverParameters::IncrementalityValues result;
4934
4935 result = (operations_research::MPSolverParameters::IncrementalityValues)(operations_research::MPSolverParameters::IncrementalityValues)operations_research::MPSolverParameters::kDefaultIncrementality;
4936 jresult = (int)result;
4937 return jresult;
4938}
4939
4940
4941SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPSolverParameters___() {
4942 void * jresult ;
4943 operations_research::MPSolverParameters *result = 0 ;
4944
4945 result = (operations_research::MPSolverParameters *)new operations_research::MPSolverParameters();
4946 jresult = (void *)result;
4947 return jresult;
4948}
4949
4950
4951SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_SetDoubleParam___(void * jarg1, int jarg2, double jarg3) {
4952 operations_research::MPSolverParameters *arg1 = (operations_research::MPSolverParameters *) 0 ;
4953 operations_research::MPSolverParameters::DoubleParam arg2 ;
4954 double arg3 ;
4955
4956 arg1 = (operations_research::MPSolverParameters *)jarg1;
4957 arg2 = (operations_research::MPSolverParameters::DoubleParam)jarg2;
4958 arg3 = (double)jarg3;
4959 (arg1)->SetDoubleParam(arg2,arg3);
4960}
4961
4962
4963SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_SetIntegerParam___(void * jarg1, int jarg2, int jarg3) {
4964 operations_research::MPSolverParameters *arg1 = (operations_research::MPSolverParameters *) 0 ;
4965 operations_research::MPSolverParameters::IntegerParam arg2 ;
4966 int arg3 ;
4967
4968 arg1 = (operations_research::MPSolverParameters *)jarg1;
4969 arg2 = (operations_research::MPSolverParameters::IntegerParam)jarg2;
4970 arg3 = (int)jarg3;
4971 (arg1)->SetIntegerParam(arg2,arg3);
4972}
4973
4974
4975SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_GetDoubleParam___(void * jarg1, int jarg2) {
4976 double jresult ;
4977 operations_research::MPSolverParameters *arg1 = (operations_research::MPSolverParameters *) 0 ;
4978 operations_research::MPSolverParameters::DoubleParam arg2 ;
4979 double result;
4980
4981 arg1 = (operations_research::MPSolverParameters *)jarg1;
4982 arg2 = (operations_research::MPSolverParameters::DoubleParam)jarg2;
4983 result = (double)((operations_research::MPSolverParameters const *)arg1)->GetDoubleParam(arg2);
4984 jresult = result;
4985 return jresult;
4986}
4987
4988
4989SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_GetIntegerParam___(void * jarg1, int jarg2) {
4990 int jresult ;
4991 operations_research::MPSolverParameters *arg1 = (operations_research::MPSolverParameters *) 0 ;
4992 operations_research::MPSolverParameters::IntegerParam arg2 ;
4993 int result;
4994
4995 arg1 = (operations_research::MPSolverParameters *)jarg1;
4996 arg2 = (operations_research::MPSolverParameters::IntegerParam)jarg2;
4997 result = (int)((operations_research::MPSolverParameters const *)arg1)->GetIntegerParam(arg2);
4998 jresult = result;
4999 return jresult;
5000}
5001
5002
5003SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_MPSolverParameters___(void * jarg1) {
5004 operations_research::MPSolverParameters *arg1 = (operations_research::MPSolverParameters *) 0 ;
5005
5006 arg1 = (operations_research::MPSolverParameters *)jarg1;
5007 delete arg1;
5008}
5009
5010
5011#ifdef __cplusplus
5012}
5013#endif
5014
LOG
#define LOG(severity)
Definition: base/logging.h:420
operations_research::MPConstraint
The class for constraints of a Mathematical Programming (MP) model.
Definition: linear_solver.h:1211
operations_research::MPModelProto
Definition: linear_solver.pb.h:2801
operations_research::MPObjective
A class to express a linear objective.
Definition: linear_solver.h:959
operations_research::MPSolver
This mathematical programming (MP) solver class is the main class though which users build and solve ...
Definition: linear_solver.h:182
operations_research::MPSolver::SupportsProblemType
static bool SupportsProblemType(OptimizationProblemType problem_type)
Whether the given problem type is supported (this will depend on the targets that you linked).
Definition: linear_solver.cc:467
operations_research::MPSolver::CreateSolver
static MPSolver * CreateSolver(const std::string &solver_id)
Recommended factory method to create a MPSolver instance, especially in non C++ languages.
Definition: linear_solver.cc:609
operations_research::MPSolver::SetHint
void SetHint(std::vector< std::pair< const MPVariable *, double > > hint)
Sets a hint for solution.
Definition: linear_solver.cc:1712
operations_research::MPSolver::ResultStatus
ResultStatus
The status of solving the problem.
Definition: linear_solver.h:438
operations_research::MPSolver::OptimizationProblemType
OptimizationProblemType
The type of problems (LP or MIP) that will be solved and the underlying solver (GLOP,...
Definition: linear_solver.h:190
operations_research::MPSolver::SetNumThreads
absl::Status SetNumThreads(int num_threads)
Sets the number of threads to use by the underlying solver.
Definition: linear_solver.cc:340
operations_research::MPSolver::ExportModelToProto
void ExportModelToProto(MPModelProto *output_model) const
Exports model to protocol buffer.
Definition: linear_solver.cc:1043
operations_research::MPSolver::ComputeConstraintActivities
std::vector< double > ComputeConstraintActivities() const
Advanced usage: compute the "activities" of all constraints, which are the sums of their linear terms...
Definition: linear_solver.cc:1505
operations_research::MPSolver::InterruptSolve
bool InterruptSolve()
Interrupts the Solve() execution to terminate processing if possible.
Definition: linear_solver.cc:1243
operations_research::MPSolver::Solve
ResultStatus Solve()
Solves the problem using the default parameter values.
Definition: linear_solver.cc:1390
operations_research::MPSolver::BasisStatus
BasisStatus
Advanced usage: possible basis status values for a variable and the slack variable of a linear constr...
Definition: linear_solver.h:672
operations_research::MPSolverParameters
This class stores parameter settings for LP and MIP solvers.
Definition: linear_solver.h:1394
operations_research::MPSolverParameters::kDefaultRelativeMipGap
static const double kDefaultRelativeMipGap
Definition: linear_solver.h:1476
operations_research::MPSolverParameters::IncrementalityValues
IncrementalityValues
Advanced usage: Incrementality options.
Definition: linear_solver.h:1443
operations_research::MPSolverParameters::kDefaultIncrementality
static const IncrementalityValues kDefaultIncrementality
Definition: linear_solver.h:1480
operations_research::MPSolverParameters::DoubleParam
DoubleParam
Enumeration of parameters that take continuous values.
Definition: linear_solver.h:1397
operations_research::MPSolverParameters::kDefaultPresolve
static const PresolveValues kDefaultPresolve
Definition: linear_solver.h:1479
operations_research::MPSolverParameters::kDefaultDualTolerance
static const double kDefaultDualTolerance
Definition: linear_solver.h:1478
operations_research::MPSolverParameters::IntegerParam
IntegerParam
Enumeration of parameters that take integer or categorical values.
Definition: linear_solver.h:1413
operations_research::MPSolverParameters::PresolveValues
PresolveValues
For each categorical parameter, enumeration of possible values.
Definition: linear_solver.h:1425
operations_research::MPSolverParameters::kDefaultPrimalTolerance
static const double kDefaultPrimalTolerance
Definition: linear_solver.h:1477
operations_research::MPVariable
The class for variables of a Mathematical Programming (MP) model.
Definition: linear_solver.h:1086
name
const std::string name
Definition: default_search.cc:813
value
int64_t value
Definition: demon_profiler.cc:44
model
GRBmodel * model
Definition: gurobi_interface.cc:274
callback
MPCallback * callback
Definition: gurobi_interface.cc:515
integral_types.h
SWIG_CSharpExceptionArgumentCodes
SWIG_CSharpExceptionArgumentCodes
Definition: knapsack_solver_csharp_wrap.cc:187
SWIG_CSharpExceptionCodes
SWIG_CSharpExceptionCodes
Definition: knapsack_solver_csharp_wrap.cc:173
linear_solver.h
A C++ wrapper that provides a simple and unified interface to several linear programming and mixed in...
linear_solver.pb.h
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_getitemcopy___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_getitemcopy___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:3158
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_SetRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_SetRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:2623
CSharp_GooglefOrToolsfLinearSolver_Solver_MakeVar___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeVar___(void *jarg1, double jarg2, double jarg3, unsigned int jarg4, char *jarg5)
Definition: linear_solver_csharp_wrap.cc:4000
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_getitem___
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_getitem___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:2006
CSharp_GooglefOrToolsfLinearSolver_Solver_constraints___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_constraints___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4102
std_vector_Sl_double_Sg__Reverse__SWIG_1
SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_1(std::vector< double > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:821
CSharp_GooglefOrToolsfLinearSolver_delete_IntVectorVector___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_IntVectorVector___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1882
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_size___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_size___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3081
std_vector_Sl_operations_research_MPVariable_Sm__Sg__getitem
SWIGINTERN std::vector< operations_research::MPVariable * >::value_type const & std_vector_Sl_operations_research_MPVariable_Sm__Sg__getitem(std::vector< operations_research::MPVariable * > *self, int index)
Definition: linear_solver_csharp_wrap.cc:994
new_std_vector_Sl_int_Sg___SWIG_2
SWIGINTERN std::vector< int > * new_std_vector_Sl_int_Sg___SWIG_2(int capacity)
Definition: linear_solver_csharp_wrap.cc:327
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_RemoveRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_RemoveRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:1790
std_vector_Sl_int_Sg__InsertRange
SWIGINTERN void std_vector_Sl_int_Sg__InsertRange(std::vector< int > *self, int index, std::vector< int > const &values)
Definition: linear_solver_csharp_wrap.cc:373
std_vector_Sl_double_Sg__RemoveRange
SWIGINTERN void std_vector_Sl_double_Sg__RemoveRange(std::vector< double > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:804
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_0
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< int64_t > > *self)
Definition: linear_solver_csharp_wrap.cc:722
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__LastIndexOf
SWIGINTERN int std_vector_Sl_operations_research_MPConstraint_Sm__Sg__LastIndexOf(std::vector< operations_research::MPConstraint * > *self, operations_research::MPConstraint *const &value)
Definition: linear_solver_csharp_wrap.cc:963
CSharp_GooglefOrToolsfLinearSolver_Solver_Solve__SWIG_0___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Solve__SWIG_0___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4229
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Repeat___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Repeat___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:2572
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_InsertRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_InsertRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:3681
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_AddRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_AddRange___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:2457
std_vector_Sl_int64_t_Sg__GetRange
SWIGINTERN std::vector< long long > * std_vector_Sl_int64_t_Sg__GetRange(std::vector< int64_t > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:565
SWIG_csharp_exceptions_argument
static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[]
Definition: linear_solver_csharp_wrap.cc:220
std_vector_Sl_std_vector_Sl_int_Sg__Sg__GetRange
SWIGINTERN std::vector< std::vector< int > > * std_vector_Sl_std_vector_Sl_int_Sg__Sg__GetRange(std::vector< std::vector< int > > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:474
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Reverse__SWIG_1___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Reverse__SWIG_1___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:3357
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_InsertRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_InsertRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:2516
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Clear___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Clear___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1890
CSharp_GooglefOrToolsfLinearSolver_delete_IntVector___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_IntVector___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1529
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_RemoveRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_RemoveRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:3308
SWIG_CSharpExceptionCallback_t
void(SWIGSTDCALL * SWIG_CSharpExceptionCallback_t)(const char *)
Definition: linear_solver_csharp_wrap.cc:193
new_std_vector_Sl_double_Sg___SWIG_2
SWIGINTERN std::vector< double > * new_std_vector_Sl_double_Sg___SWIG_2(int capacity)
Definition: linear_solver_csharp_wrap.cc:746
std_vector_Sl_double_Sg__GetRange
SWIGINTERN std::vector< double > * std_vector_Sl_double_Sg__GetRange(std::vector< double > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:777
SWIG_CSharpExceptionArgumentCallback_t
void(SWIGSTDCALL * SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *)
Definition: linear_solver_csharp_wrap.cc:194
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Insert
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Insert(std::vector< std::vector< int64_t > > *self, int index, std::vector< int64_t > const &x)
Definition: linear_solver_csharp_wrap.cc:690
CSharp_GooglefOrToolsfLinearSolver_new_IntVectorVector__SWIG_0___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVectorVector__SWIG_0___()
Definition: linear_solver_csharp_wrap.cc:1593
std_vector_Sl_int_Sg__Repeat
SWIGINTERN std::vector< int > * std_vector_Sl_int_Sg__Repeat(int const &value, int count)
Definition: linear_solver_csharp_wrap.cc:394
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_getitemcopy___
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_getitemcopy___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1987
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Add___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Add___(void *jarg1, long long jarg2)
Definition: linear_solver_csharp_wrap.cc:1898
CSharp_GooglefOrToolsfLinearSolver_Solver_SuppressOutput___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SuppressOutput___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4336
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Reverse__SWIG_1___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Reverse__SWIG_1___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:3766
std_vector_Sl_double_Sg__AddRange
SWIGINTERN void std_vector_Sl_double_Sg__AddRange(std::vector< double > *self, std::vector< double > const &values)
Definition: linear_solver_csharp_wrap.cc:774
std_vector_Sl_operations_research_MPVariable_Sm__Sg__SetRange
SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__SetRange(std::vector< operations_research::MPVariable * > *self, int index, std::vector< operations_research::MPVariable * > const &values)
Definition: linear_solver_csharp_wrap.cc:1062
std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_1
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< int > > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:518
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Add___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Add___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3478
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Add___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Add___(void *jarg1, double jarg2)
Definition: linear_solver_csharp_wrap.cc:2660
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_capacity___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_capacity___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2333
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Contains___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Contains___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3398
std_vector_Sl_double_Sg__Repeat
SWIGINTERN std::vector< double > * std_vector_Sl_double_Sg__Repeat(double const &value, int count)
Definition: linear_solver_csharp_wrap.cc:813
new_std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg___SWIG_2
SWIGINTERN std::vector< std::vector< int64_t > > * new_std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg___SWIG_2(int capacity)
Definition: linear_solver_csharp_wrap.cc:650
std_vector_Sl_operations_research_MPVariable_Sm__Sg__Insert
SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__Insert(std::vector< operations_research::MPVariable * > *self, int index, operations_research::MPVariable *const &x)
Definition: linear_solver_csharp_wrap.cc:1018
SWIG_CSharpSetPendingExceptionArgument
static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name)
Definition: linear_solver_csharp_wrap.cc:234
CSharp_GooglefOrToolsfLinearSolver_Solver_ExportModelAsMpsFormat___
SWIGEXPORT char *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_ExportModelAsMpsFormat___(void *jarg1, unsigned int jarg2, unsigned int jarg3)
Definition: linear_solver_csharp_wrap.cc:4416
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Insert___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Insert___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:2495
CSharp_GooglefOrToolsfLinearSolver_Objective_BestBound___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_BestBound___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4589
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Remove___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Remove___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3855
CSharp_GooglefOrToolsfLinearSolver_Solver_Nodes___
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Nodes___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4356
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_getitem___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_getitem___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:3177
new_std_vector_Sl_operations_research_MPVariable_Sm__Sg___SWIG_2
SWIGINTERN std::vector< operations_research::MPVariable * > * new_std_vector_Sl_operations_research_MPVariable_Sm__Sg___SWIG_2(int capacity)
Definition: linear_solver_csharp_wrap.cc:978
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_GetRange___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_GetRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:2058
CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_0___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_0___(void *jarg1, double jarg2, double jarg3)
Definition: linear_solver_csharp_wrap.cc:4147
CSharp_GooglefOrToolsfLinearSolver_Solver_Reset___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Reset___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4289
CSharp_GooglefOrToolsfLinearSolver_Constraint_Index___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_Index___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4847
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__AddRange
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__AddRange(std::vector< std::vector< int64_t > > *self, std::vector< std::vector< int64_t > > const &values)
Definition: linear_solver_csharp_wrap.cc:678
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_size___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_size___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1559
CSharp_GooglefOrToolsfLinearSolver_Constraint_SetIsLazy___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_SetIsLazy___(void *jarg1, unsigned int jarg2)
Definition: linear_solver_csharp_wrap.cc:4837
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_capacity___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_capacity___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1922
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_InsertRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_InsertRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:2863
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_reserve___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_reserve___(void *jarg1, unsigned long jarg2)
Definition: linear_solver_csharp_wrap.cc:3514
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_RemoveRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_RemoveRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:2899
CSharp_GooglefOrToolsfLinearSolver_new_MPSolverParameters___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPSolverParameters___()
Definition: linear_solver_csharp_wrap.cc:4941
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveRange
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveRange(std::vector< std::vector< int64_t > > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:708
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_RemoveAt___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_RemoveAt___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:3702
CSharp_GooglefOrToolsfLinearSolver_Variable_Name___
SWIGEXPORT char *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_Name___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4609
CSharp_GooglefOrToolsfLinearSolver_new_Int64Vector__SWIG_2___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64Vector__SWIG_2___(int jarg1)
Definition: linear_solver_csharp_wrap.cc:1970
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__GetRange
SWIGINTERN std::vector< std::vector< int64_t > > * std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__GetRange(std::vector< std::vector< int64_t > > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:681
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Clear___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Clear___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2299
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Repeat___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Repeat___(double jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:2919
CSharp_GooglefOrToolsfLinearSolver_new_MPConstraintVector__SWIG_1___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPConstraintVector__SWIG_1___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3125
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_reserve___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_reserve___(void *jarg1, unsigned long jarg2)
Definition: linear_solver_csharp_wrap.cc:2696
CSharp_GooglefOrToolsfLinearSolver_delete_MPConstraintVector___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_MPConstraintVector___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3462
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_IndexOf___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_IndexOf___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3823
new_std_vector_Sl_std_vector_Sl_int_Sg__Sg___SWIG_2
SWIGINTERN std::vector< std::vector< int > > * new_std_vector_Sl_std_vector_Sl_int_Sg__Sg___SWIG_2(int capacity)
Definition: linear_solver_csharp_wrap.cc:443
std_vector_Sl_std_vector_Sl_int_Sg__Sg__InsertRange
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__InsertRange(std::vector< std::vector< int > > *self, int index, std::vector< std::vector< int > > const &values)
Definition: linear_solver_csharp_wrap.cc:489
std_vector_Sl_int64_t_Sg__Repeat
SWIGINTERN std::vector< long long > * std_vector_Sl_int64_t_Sg__Repeat(long long const &value, int count)
Definition: linear_solver_csharp_wrap.cc:601
std_vector_Sl_int_Sg__Contains
SWIGINTERN bool std_vector_Sl_int_Sg__Contains(std::vector< int > *self, int const &value)
Definition: linear_solver_csharp_wrap.cc:418
CSharp_GooglefOrToolsfLinearSolver_Solver_SetTimeLimit___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SetTimeLimit___(void *jarg1, long long jarg2)
Definition: linear_solver_csharp_wrap.cc:4380
std_vector_Sl_int64_t_Sg__Insert
SWIGINTERN void std_vector_Sl_int64_t_Sg__Insert(std::vector< int64_t > *self, int index, long long const &x)
Definition: linear_solver_csharp_wrap.cc:574
CSharp_GooglefOrToolsfLinearSolver_new_Int64Vector__SWIG_0___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64Vector__SWIG_0___()
Definition: linear_solver_csharp_wrap.cc:1944
SWIGRegisterStringCallback_operations_research_linear_solver
SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_operations_research_linear_solver(SWIG_CSharpStringHelperCallback callback)
Definition: linear_solver_csharp_wrap.cc:292
CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_1___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_1___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4163
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Reverse__SWIG_0___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Reverse__SWIG_0___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3758
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_setitem___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_setitem___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:2436
CSharp_GooglefOrToolsfLinearSolver_Constraint_SetUb___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_SetUb___(void *jarg1, double jarg2)
Definition: linear_solver_csharp_wrap.cc:4803
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Repeat
SWIGINTERN std::vector< std::vector< int64_t > > * std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Repeat(std::vector< int64_t > const &value, int count)
Definition: linear_solver_csharp_wrap.cc:717
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Reverse__SWIG_0___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Reverse__SWIG_0___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3349
std_vector_Sl_int64_t_Sg__setitem
SWIGINTERN void std_vector_Sl_int64_t_Sg__setitem(std::vector< int64_t > *self, int index, long long const &val)
Definition: linear_solver_csharp_wrap.cc:556
std_vector_Sl_double_Sg__RemoveAt
SWIGINTERN void std_vector_Sl_double_Sg__RemoveAt(std::vector< double > *self, int index)
Definition: linear_solver_csharp_wrap.cc:798
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_InsertRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_InsertRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:2101
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Reverse__SWIG_0___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Reverse__SWIG_0___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2178
std_vector_Sl_int_Sg__LastIndexOf
SWIGINTERN int std_vector_Sl_int_Sg__LastIndexOf(std::vector< int > *self, int const &value)
Definition: linear_solver_csharp_wrap.cc:428
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_SetRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_SetRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:2968
CSharp_GooglefOrToolsfLinearSolver_IntVector_reserve___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_reserve___(void *jarg1, unsigned long jarg2)
Definition: linear_solver_csharp_wrap.cc:1172
CSharp_GooglefOrToolsfLinearSolver_IntVector_LastIndexOf___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_LastIndexOf___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1497
std_vector_Sl_int_Sg__Reverse__SWIG_1
SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_1(std::vector< int > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:402
CSharp_GooglefOrToolsfLinearSolver_IntVector_setitem___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_setitem___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:1263
CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_GetIntegerParam___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_GetIntegerParam___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:4989
CSharp_GooglefOrToolsfLinearSolver_new_Int64VectorVector__SWIG_1___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64VectorVector__SWIG_1___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2365
std_vector_Sl_std_vector_Sl_int_Sg__Sg__SetRange
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__SetRange(std::vector< std::vector< int > > *self, int index, std::vector< std::vector< int > > const &values)
Definition: linear_solver_csharp_wrap.cc:527
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Clear___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Clear___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3470
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Insert
SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Insert(std::vector< operations_research::MPConstraint * > *self, int index, operations_research::MPConstraint *const &x)
Definition: linear_solver_csharp_wrap.cc:902
CSharp_GooglefOrToolsfLinearSolver_Solver_LookupVariableOrNull___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_LookupVariableOrNull___(void *jarg1, char *jarg2)
Definition: linear_solver_csharp_wrap.cc:3981
CSharp_GooglefOrToolsfLinearSolver_Constraint_BasisStatus___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_BasisStatus___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4871
CSharp_GooglefOrToolsfLinearSolver_Constraint_SetLb___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_SetLb___(void *jarg1, double jarg2)
Definition: linear_solver_csharp_wrap.cc:4793
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__InsertRange
SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__InsertRange(std::vector< operations_research::MPConstraint * > *self, int index, std::vector< operations_research::MPConstraint * > const &values)
Definition: linear_solver_csharp_wrap.cc:908
CSharp_GooglefOrToolsfLinearSolver_IntVector_GetRange___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_GetRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:1296
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__getitemcopy
SWIGINTERN operations_research::MPConstraint * std_vector_Sl_operations_research_MPConstraint_Sm__Sg__getitemcopy(std::vector< operations_research::MPConstraint * > *self, int index)
Definition: linear_solver_csharp_wrap.cc:872
std_vector_Sl_int64_t_Sg__AddRange
SWIGINTERN void std_vector_Sl_int64_t_Sg__AddRange(std::vector< int64_t > *self, std::vector< long long > const &values)
Definition: linear_solver_csharp_wrap.cc:562
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Clear___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Clear___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1537
std_vector_Sl_operations_research_MPVariable_Sm__Sg__RemoveRange
SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__RemoveRange(std::vector< operations_research::MPVariable * > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:1036
CSharp_GooglefOrToolsfLinearSolver_delete_Constraint___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Constraint___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4883
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_size___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_size___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3490
CSharp_GooglefOrToolsfLinearSolver_new_MPConstraintVector__SWIG_2___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPConstraintVector__SWIG_2___(int jarg1)
Definition: linear_solver_csharp_wrap.cc:3141
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_getitemcopy___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_getitemcopy___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:2398
std_vector_Sl_int_Sg__AddRange
SWIGINTERN void std_vector_Sl_int_Sg__AddRange(std::vector< int > *self, std::vector< int > const &values)
Definition: linear_solver_csharp_wrap.cc:355
new_std_vector_Sl_int64_t_Sg___SWIG_2
SWIGINTERN std::vector< int64_t > * new_std_vector_Sl_int64_t_Sg___SWIG_2(int capacity)
Definition: linear_solver_csharp_wrap.cc:534
std_vector_Sl_operations_research_MPVariable_Sm__Sg__RemoveAt
SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__RemoveAt(std::vector< operations_research::MPVariable * > *self, int index)
Definition: linear_solver_csharp_wrap.cc:1030
CSharp_GooglefOrToolsfLinearSolver_Objective_SetOptimizationDirection___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_SetOptimizationDirection___(void *jarg1, unsigned int jarg2)
Definition: linear_solver_csharp_wrap.cc:4527
std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveRange
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveRange(std::vector< std::vector< int > > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:501
std_vector_Sl_int64_t_Sg__InsertRange
SWIGINTERN void std_vector_Sl_int64_t_Sg__InsertRange(std::vector< int64_t > *self, int index, std::vector< long long > const &values)
Definition: linear_solver_csharp_wrap.cc:580
std_vector_Sl_int_Sg__getitemcopy
SWIGINTERN int std_vector_Sl_int_Sg__getitemcopy(std::vector< int > *self, int index)
Definition: linear_solver_csharp_wrap.cc:337
CSharp_GooglefOrToolsfLinearSolver_IntVector_Remove___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Remove___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1513
std_vector_Sl_operations_research_MPVariable_Sm__Sg__IndexOf
SWIGINTERN int std_vector_Sl_operations_research_MPVariable_Sm__Sg__IndexOf(std::vector< operations_research::MPVariable * > *self, operations_research::MPVariable *const &value)
Definition: linear_solver_csharp_wrap.cc:1072
std_vector_Sl_double_Sg__getitem
SWIGINTERN std::vector< double >::value_type const & std_vector_Sl_double_Sg__getitem(std::vector< double > *self, int index)
Definition: linear_solver_csharp_wrap.cc:762
CSharp_GooglefOrToolsfLinearSolver_delete_Int64VectorVector___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Int64VectorVector___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2644
CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultPrimalTolerance_get___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultPrimalTolerance_get___()
Definition: linear_solver_csharp_wrap.cc:4901
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_setitem___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_setitem___(void *jarg1, int jarg2, long long jarg3)
Definition: linear_solver_csharp_wrap.cc:2025
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_reserve___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_reserve___(void *jarg1, unsigned long jarg2)
Definition: linear_solver_csharp_wrap.cc:1583
CSharp_GooglefOrToolsfLinearSolver_new_Solver___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Solver___(char *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:3879
std_vector_Sl_double_Sg__setitem
SWIGINTERN void std_vector_Sl_double_Sg__setitem(std::vector< double > *self, int index, double const &val)
Definition: linear_solver_csharp_wrap.cc:768
CSharp_GooglefOrToolsfLinearSolver_Objective_SetCoefficient___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_SetCoefficient___(void *jarg1, void *jarg2, double jarg3)
Definition: linear_solver_csharp_wrap.cc:4479
CSharp_GooglefOrToolsfLinearSolver_IntVector_size___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_size___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1148
CSharp_GooglefOrToolsfLinearSolver_Solver_EnableOutput___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_EnableOutput___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4328
CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultRelativeMipGap_get___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultRelativeMipGap_get___()
Definition: linear_solver_csharp_wrap.cc:4891
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Insert___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Insert___(void *jarg1, int jarg2, double jarg3)
Definition: linear_solver_csharp_wrap.cc:2844
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Insert___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Insert___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:3662
CSharp_GooglefOrToolsfLinearSolver_Solver_SupportsProblemType___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SupportsProblemType___(int jarg1)
Definition: linear_solver_csharp_wrap.cc:3923
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_LastIndexOf___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_LastIndexOf___(void *jarg1, double jarg2)
Definition: linear_solver_csharp_wrap.cc:3021
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Remove___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Remove___(void *jarg1, long long jarg2)
Definition: linear_solver_csharp_wrap.cc:2275
std_vector_Sl_int_Sg__Remove
SWIGINTERN bool std_vector_Sl_int_Sg__Remove(std::vector< int > *self, int const &value)
Definition: linear_solver_csharp_wrap.cc:435
CSharp_GooglefOrToolsfLinearSolver_IntVector_AddRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_AddRange___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:1282
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_setitem___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_setitem___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:3196
CSharp_GooglefOrToolsfLinearSolver_Variable_BasisStatus___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_BasisStatus___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4711
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_setitem___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_setitem___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:1674
std_vector_Sl_double_Sg__Remove
SWIGINTERN bool std_vector_Sl_double_Sg__Remove(std::vector< double > *self, double const &value)
Definition: linear_solver_csharp_wrap.cc:854
std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitemcopy
SWIGINTERN std::vector< int > std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitemcopy(std::vector< std::vector< int > > *self, int index)
Definition: linear_solver_csharp_wrap.cc:453
CSharp_GooglefOrToolsfLinearSolver_Constraint_IsLazy___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_IsLazy___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4825
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Contains___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Contains___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3807
CSharp_GooglefOrToolsfLinearSolver_new_IntVector__SWIG_0___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVector__SWIG_0___()
Definition: linear_solver_csharp_wrap.cc:1182
std_vector_Sl_int64_t_Sg__Reverse__SWIG_0
SWIGINTERN void std_vector_Sl_int64_t_Sg__Reverse__SWIG_0(std::vector< int64_t > *self)
Definition: linear_solver_csharp_wrap.cc:606
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_getitemcopy___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_getitemcopy___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:2749
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Add___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Add___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:2307
std_vector_Sl_int_Sg__Reverse__SWIG_0
SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_0(std::vector< int > *self)
Definition: linear_solver_csharp_wrap.cc:399
CSharp_GooglefOrToolsfLinearSolver_IntVector_Repeat___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Repeat___(int jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1395
CSharp_GooglefOrToolsfLinearSolver_Solver_VerifySolution___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_VerifySolution___(void *jarg1, double jarg2, unsigned int jarg3)
Definition: linear_solver_csharp_wrap.cc:4273
CSharp_GooglefOrToolsfLinearSolver_Solver_ComputeExactConditionNumber___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_ComputeExactConditionNumber___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4368
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_setitem___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_setitem___(void *jarg1, int jarg2, double jarg3)
Definition: linear_solver_csharp_wrap.cc:2787
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_capacity___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_capacity___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3502
std_vector_Sl_double_Sg__LastIndexOf
SWIGINTERN int std_vector_Sl_double_Sg__LastIndexOf(std::vector< double > *self, double const &value)
Definition: linear_solver_csharp_wrap.cc:847
CSharp_GooglefOrToolsfLinearSolver_delete_Objective___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Objective___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4601
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Reverse__SWIG_1___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Reverse__SWIG_1___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:2186
CSharp_GooglefOrToolsfLinearSolver_Constraint_GetCoefficient___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_GetCoefficient___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:4755
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Repeat
SWIGINTERN std::vector< operations_research::MPConstraint * > * std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Repeat(operations_research::MPConstraint *const &value, int count)
Definition: linear_solver_csharp_wrap.cc:929
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Clear___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Clear___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3061
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_InsertRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_InsertRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:1754
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_IndexOf___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_IndexOf___(void *jarg1, long long jarg2)
Definition: linear_solver_csharp_wrap.cc:2243
CSharp_GooglefOrToolsfLinearSolver_IntVector_RemoveRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_RemoveRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:1375
CSharp_GooglefOrToolsfLinearSolver_Variable_SetUb___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_SetUb___(void *jarg1, double jarg2)
Definition: linear_solver_csharp_wrap.cc:4677
SWIG_csharp_string_callback
static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback
Definition: linear_solver_csharp_wrap.cc:286
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_reserve___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_reserve___(void *jarg1, unsigned long jarg2)
Definition: linear_solver_csharp_wrap.cc:1934
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Contains___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Contains___(void *jarg1, double jarg2)
Definition: linear_solver_csharp_wrap.cc:2989
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Add___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Add___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3069
SWIGUNUSED
#define SWIGUNUSED
Definition: linear_solver_csharp_wrap.cc:79
CSharp_GooglefOrToolsfLinearSolver_IntVector_InsertRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_InsertRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:1339
std_vector_Sl_double_Sg__InsertRange
SWIGINTERN void std_vector_Sl_double_Sg__InsertRange(std::vector< double > *self, int index, std::vector< double > const &values)
Definition: linear_solver_csharp_wrap.cc:792
CSharp_GooglefOrToolsfLinearSolver_Solver_Clear___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Clear___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3935
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveAt
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveAt(std::vector< std::vector< int64_t > > *self, int index)
Definition: linear_solver_csharp_wrap.cc:702
SWIG_csharp_exceptions
static SWIG_CSharpException_t SWIG_csharp_exceptions[]
Definition: linear_solver_csharp_wrap.cc:206
CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_SetIntegerParam___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_SetIntegerParam___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:4963
std_vector_Sl_operations_research_MPVariable_Sm__Sg__getitemcopy
SWIGINTERN operations_research::MPVariable * std_vector_Sl_operations_research_MPVariable_Sm__Sg__getitemcopy(std::vector< operations_research::MPVariable * > *self, int index)
Definition: linear_solver_csharp_wrap.cc:988
CSharp_GooglefOrToolsfLinearSolver_new_MPVariableVector__SWIG_1___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPVariableVector__SWIG_1___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3534
std_vector_Sl_operations_research_MPVariable_Sm__Sg__GetRange
SWIGINTERN std::vector< operations_research::MPVariable * > * std_vector_Sl_operations_research_MPVariable_Sm__Sg__GetRange(std::vector< operations_research::MPVariable * > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:1009
CSharp_GooglefOrToolsfLinearSolver_Constraint_SetBounds___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_SetBounds___(void *jarg1, double jarg2, double jarg3)
Definition: linear_solver_csharp_wrap.cc:4813
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_GetRange___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_GetRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:2471
std_vector_Sl_std_vector_Sl_int_Sg__Sg__Insert
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Insert(std::vector< std::vector< int > > *self, int index, std::vector< int > const &x)
Definition: linear_solver_csharp_wrap.cc:483
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Contains
SWIGINTERN bool std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Contains(std::vector< operations_research::MPConstraint * > *self, operations_research::MPConstraint *const &value)
Definition: linear_solver_csharp_wrap.cc:953
std_vector_Sl_operations_research_MPVariable_Sm__Sg__Remove
SWIGINTERN bool std_vector_Sl_operations_research_MPVariable_Sm__Sg__Remove(std::vector< operations_research::MPVariable * > *self, operations_research::MPVariable *const &value)
Definition: linear_solver_csharp_wrap.cc:1086
CSharp_GooglefOrToolsfLinearSolver_IntVector_IndexOf___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_IndexOf___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1481
std_vector_Sl_std_vector_Sl_int_Sg__Sg__setitem
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__setitem(std::vector< std::vector< int > > *self, int index, std::vector< int > const &val)
Definition: linear_solver_csharp_wrap.cc:465
CSharp_GooglefOrToolsfLinearSolver_Solver_variables___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_variables___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3955
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Repeat___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Repeat___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:3328
CSharp_GooglefOrToolsfLinearSolver_Solver_MakeNumVar___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeNumVar___(void *jarg1, double jarg2, double jarg3, char *jarg4)
Definition: linear_solver_csharp_wrap.cc:4025
CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultDualTolerance_get___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultDualTolerance_get___()
Definition: linear_solver_csharp_wrap.cc:4911
CSharp_GooglefOrToolsfLinearSolver_new_Int64VectorVector__SWIG_2___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64VectorVector__SWIG_2___(int jarg1)
Definition: linear_solver_csharp_wrap.cc:2381
CSharp_GooglefOrToolsfLinearSolver_Solver_InterruptSolve___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_InterruptSolve___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4297
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Reverse__SWIG_0
SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::MPConstraint * > *self)
Definition: linear_solver_csharp_wrap.cc:934
SWIGRegisterExceptionArgumentCallbacks_operations_research_linear_solver
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_operations_research_linear_solver(SWIG_CSharpExceptionArgumentCallback_t argumentCallback, SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback, SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback)
Definition: linear_solver_csharp_wrap.cc:274
CSharp_GooglefOrToolsfLinearSolver_Objective_SetMaximization___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_SetMaximization___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4545
CSharp_GooglefOrToolsfLinearSolver_IntVector_Clear___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Clear___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1128
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_RemoveAt___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_RemoveAt___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:2122
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_RemoveRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_RemoveRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:2137
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_AddRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_AddRange___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:2806
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Reverse__SWIG_0___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Reverse__SWIG_0___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1833
CSharp_GooglefOrToolsfLinearSolver_Variable_SolutionValue___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_SolutionValue___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4631
CSharp_GooglefOrToolsfLinearSolver_new_IntVectorVector__SWIG_1___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVectorVector__SWIG_1___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1603
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Reverse__SWIG_1___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Reverse__SWIG_1___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:2948
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Reverse__SWIG_1___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Reverse__SWIG_1___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:2603
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__setitem
SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__setitem(std::vector< operations_research::MPConstraint * > *self, int index, operations_research::MPConstraint *const &val)
Definition: linear_solver_csharp_wrap.cc:884
std_vector_Sl_int64_t_Sg__getitemcopy
SWIGINTERN long long std_vector_Sl_int64_t_Sg__getitemcopy(std::vector< int64_t > *self, int index)
Definition: linear_solver_csharp_wrap.cc:544
CSharp_GooglefOrToolsfLinearSolver_Solver_MakeIntVar___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeIntVar___(void *jarg1, double jarg2, double jarg3, char *jarg4)
Definition: linear_solver_csharp_wrap.cc:4048
CSharp_GooglefOrToolsfLinearSolver_Objective_Minimization___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_Minimization___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4565
CSharp_GooglefOrToolsfLinearSolver_new_MPVariableVector__SWIG_0___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPVariableVector__SWIG_0___()
Definition: linear_solver_csharp_wrap.cc:3524
CSharp_GooglefOrToolsfLinearSolver_new_IntVector__SWIG_1___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVector__SWIG_1___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1192
std_vector_Sl_operations_research_MPVariable_Sm__Sg__setitem
SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__setitem(std::vector< operations_research::MPVariable * > *self, int index, operations_research::MPVariable *const &val)
Definition: linear_solver_csharp_wrap.cc:1000
CSharp_GooglefOrToolsfLinearSolver_delete_Solver___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Solver___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3898
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Contains___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Contains___(void *jarg1, long long jarg2)
Definition: linear_solver_csharp_wrap.cc:2227
SWIGRegisterExceptionCallbacks_operations_research_linear_solver
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_operations_research_linear_solver(SWIG_CSharpExceptionCallback_t applicationCallback, SWIG_CSharpExceptionCallback_t arithmeticCallback, SWIG_CSharpExceptionCallback_t divideByZeroCallback, SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, SWIG_CSharpExceptionCallback_t invalidCastCallback, SWIG_CSharpExceptionCallback_t invalidOperationCallback, SWIG_CSharpExceptionCallback_t ioCallback, SWIG_CSharpExceptionCallback_t nullReferenceCallback, SWIG_CSharpExceptionCallback_t outOfMemoryCallback, SWIG_CSharpExceptionCallback_t overflowCallback, SWIG_CSharpExceptionCallback_t systemCallback)
Definition: linear_solver_csharp_wrap.cc:246
std_vector_Sl_int64_t_Sg__Contains
SWIGINTERN bool std_vector_Sl_int64_t_Sg__Contains(std::vector< int64_t > *self, long long const &value)
Definition: linear_solver_csharp_wrap.cc:625
std_vector_Sl_int_Sg__GetRange
SWIGINTERN std::vector< int > * std_vector_Sl_int_Sg__GetRange(std::vector< int > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:358
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_SetRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_SetRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:3786
new_std_vector_Sl_operations_research_MPConstraint_Sm__Sg___SWIG_2
SWIGINTERN std::vector< operations_research::MPConstraint * > * new_std_vector_Sl_operations_research_MPConstraint_Sm__Sg___SWIG_2(int capacity)
Definition: linear_solver_csharp_wrap.cc:862
operations_research_MPSolver_SetHint
SWIGINTERN void operations_research_MPSolver_SetHint(operations_research::MPSolver *self, std::vector< operations_research::MPVariable * > const &variables, std::vector< double > const &values)
Definition: linear_solver_csharp_wrap.cc:1108
std_vector_Sl_operations_research_MPVariable_Sm__Sg__Contains
SWIGINTERN bool std_vector_Sl_operations_research_MPVariable_Sm__Sg__Contains(std::vector< operations_research::MPVariable * > *self, operations_research::MPVariable *const &value)
Definition: linear_solver_csharp_wrap.cc:1069
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__InsertRange
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__InsertRange(std::vector< std::vector< int64_t > > *self, int index, std::vector< std::vector< int64_t > > const &values)
Definition: linear_solver_csharp_wrap.cc:696
std_vector_Sl_int64_t_Sg__SetRange
SWIGINTERN void std_vector_Sl_int64_t_Sg__SetRange(std::vector< int64_t > *self, int index, std::vector< long long > const &values)
Definition: linear_solver_csharp_wrap.cc:618
CSharp_GooglefOrToolsfLinearSolver_IntVector_Add___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Add___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1136
SWIGINTERN
#define SWIGINTERN
Definition: linear_solver_csharp_wrap.cc:99
CSharp_GooglefOrToolsfLinearSolver_IntVector_SetRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_SetRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:1444
CSharp_GooglefOrToolsfLinearSolver_Solver_ExportModelAsLpFormat___
SWIGEXPORT char *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_ExportModelAsLpFormat___(void *jarg1, unsigned int jarg2)
Definition: linear_solver_csharp_wrap.cc:4402
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_getitemcopy___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_getitemcopy___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1636
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_IndexOf___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_IndexOf___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3414
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_getitem___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_getitem___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:3586
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_InsertRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_InsertRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:3272
CSharp_GooglefOrToolsfLinearSolver_IntVector_Insert___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Insert___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:1320
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_getitem___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_getitem___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:2768
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Reverse__SWIG_1___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Reverse__SWIG_1___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:1841
SWIG_CSharpExceptionArgumentCodes
SWIG_CSharpExceptionArgumentCodes
Definition: linear_solver_csharp_wrap.cc:187
SWIG_CSharpArgumentException
@ SWIG_CSharpArgumentException
Definition: linear_solver_csharp_wrap.cc:188
SWIG_CSharpArgumentOutOfRangeException
@ SWIG_CSharpArgumentOutOfRangeException
Definition: linear_solver_csharp_wrap.cc:190
SWIG_CSharpArgumentNullException
@ SWIG_CSharpArgumentNullException
Definition: linear_solver_csharp_wrap.cc:189
std_vector_Sl_int64_t_Sg__Remove
SWIGINTERN bool std_vector_Sl_int64_t_Sg__Remove(std::vector< int64_t > *self, long long const &value)
Definition: linear_solver_csharp_wrap.cc:642
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Reverse__SWIG_1
SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::MPConstraint * > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:937
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_RemoveAt___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_RemoveAt___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:2884
std_vector_Sl_double_Sg__getitemcopy
SWIGINTERN double std_vector_Sl_double_Sg__getitemcopy(std::vector< double > *self, int index)
Definition: linear_solver_csharp_wrap.cc:756
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Insert___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Insert___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:3253
CSharp_GooglefOrToolsfLinearSolver_IntVector_getitemcopy___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_getitemcopy___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1225
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Reverse__SWIG_0___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Reverse__SWIG_0___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2940
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_setitem___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_setitem___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:3605
CSharp_GooglefOrToolsfLinearSolver_delete_MPSolverParameters___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_MPSolverParameters___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:5003
CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_GetDoubleParam___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_GetDoubleParam___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:4975
CSharp_GooglefOrToolsfLinearSolver_new_DoubleVector__SWIG_2___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_DoubleVector__SWIG_2___(int jarg1)
Definition: linear_solver_csharp_wrap.cc:2732
CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_2___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_2___(void *jarg1, double jarg2, double jarg3, char *jarg4)
Definition: linear_solver_csharp_wrap.cc:4175
std_vector_Sl_operations_research_MPVariable_Sm__Sg__Reverse__SWIG_0
SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::MPVariable * > *self)
Definition: linear_solver_csharp_wrap.cc:1050
CSharp_GooglefOrToolsfLinearSolver_new_Int64VectorVector__SWIG_0___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64VectorVector__SWIG_0___()
Definition: linear_solver_csharp_wrap.cc:2355
std_vector_Sl_int64_t_Sg__getitem
SWIGINTERN std::vector< longlong >::value_type const & std_vector_Sl_int64_t_Sg__getitem(std::vector< int64_t > *self, int index)
Definition: linear_solver_csharp_wrap.cc:550
CSharp_GooglefOrToolsfLinearSolver_IntVector_RemoveAt___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_RemoveAt___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1360
CSharp_GooglefOrToolsfLinearSolver_Constraint_Ub___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_Ub___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4781
std_vector_Sl_int_Sg__RemoveRange
SWIGINTERN void std_vector_Sl_int_Sg__RemoveRange(std::vector< int > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:385
std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_0
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< int > > *self)
Definition: linear_solver_csharp_wrap.cc:515
SWIG_CSharpStringHelperCallback
char *(SWIGSTDCALL * SWIG_CSharpStringHelperCallback)(const char *)
Definition: linear_solver_csharp_wrap.cc:285
operations_research_MPSolver_ExportModelAsLpFormat
SWIGINTERN std::string operations_research_MPSolver_ExportModelAsLpFormat(operations_research::MPSolver *self, bool obfuscated)
Definition: linear_solver_csharp_wrap.cc:1094
CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_3___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeConstraint__SWIG_3___(void *jarg1, char *jarg2)
Definition: linear_solver_csharp_wrap.cc:4198
CSharp_GooglefOrToolsfLinearSolver_Variable_ReducedCost___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_ReducedCost___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4699
CSharp_GooglefOrToolsfLinearSolver_new_MPConstraintVector__SWIG_0___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPConstraintVector__SWIG_0___()
Definition: linear_solver_csharp_wrap.cc:3115
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_SetRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_SetRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:1861
CSharp_GooglefOrToolsfLinearSolver_Solver_WallTime___
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_WallTime___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4390
CSharp_GooglefOrToolsfLinearSolver_Variable_SetLb___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_SetLb___(void *jarg1, double jarg2)
Definition: linear_solver_csharp_wrap.cc:4667
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__SetRange
SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__SetRange(std::vector< operations_research::MPConstraint * > *self, int index, std::vector< operations_research::MPConstraint * > const &values)
Definition: linear_solver_csharp_wrap.cc:946
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Clear___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Clear___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2652
CSharp_GooglefOrToolsfLinearSolver_Objective_Maximization___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_Maximization___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4553
CSharp_GooglefOrToolsfLinearSolver_IntVector_capacity___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_capacity___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1160
CSharp_GooglefOrToolsfLinearSolver_Constraint_DualValue___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_DualValue___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4859
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_capacity___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_capacity___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3093
CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_SetDoubleParam___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_SetDoubleParam___(void *jarg1, int jarg2, double jarg3)
Definition: linear_solver_csharp_wrap.cc:4951
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Repeat___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Repeat___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1810
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_reserve___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_reserve___(void *jarg1, unsigned long jarg2)
Definition: linear_solver_csharp_wrap.cc:2345
std_vector_Sl_operations_research_MPVariable_Sm__Sg__Repeat
SWIGINTERN std::vector< operations_research::MPVariable * > * std_vector_Sl_operations_research_MPVariable_Sm__Sg__Repeat(operations_research::MPVariable *const &value, int count)
Definition: linear_solver_csharp_wrap.cc:1045
CSharp_GooglefOrToolsfLinearSolver_delete_DoubleVector___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_DoubleVector___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3053
CSharp_GooglefOrToolsfLinearSolver_Variable_SetInteger___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_SetInteger___(void *jarg1, unsigned int jarg2)
Definition: linear_solver_csharp_wrap.cc:4621
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Add___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Add___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:1545
CSharp_GooglefOrToolsfLinearSolver_Solver_SetNumThreads___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SetNumThreads___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:4457
CSharp_GooglefOrToolsfLinearSolver_Objective_SetMinimization___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_SetMinimization___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4537
CSharp_GooglefOrToolsfLinearSolver_Objective_Offset___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_Offset___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4515
CSharp_GooglefOrToolsfLinearSolver_new_IntVector__SWIG_2___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVector__SWIG_2___(int jarg1)
Definition: linear_solver_csharp_wrap.cc:1208
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_AddRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_AddRange___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3624
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Remove
SWIGINTERN bool std_vector_Sl_operations_research_MPConstraint_Sm__Sg__Remove(std::vector< operations_research::MPConstraint * > *self, operations_research::MPConstraint *const &value)
Definition: linear_solver_csharp_wrap.cc:970
CSharp_GooglefOrToolsfLinearSolver_Solver_NumVariables___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_NumVariables___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3943
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_LastIndexOf___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_LastIndexOf___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3430
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_GetRange___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_GetRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:1709
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_RemoveRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_RemoveRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:2552
CSharp_GooglefOrToolsfLinearSolver_Solver_Iterations___
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Iterations___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4344
std_vector_Sl_std_vector_Sl_int_Sg__Sg__Repeat
SWIGINTERN std::vector< std::vector< int > > * std_vector_Sl_std_vector_Sl_int_Sg__Sg__Repeat(std::vector< int > const &value, int count)
Definition: linear_solver_csharp_wrap.cc:510
CSharp_GooglefOrToolsfLinearSolver_Solver_Objective___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Objective___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4217
CSharp_GooglefOrToolsfLinearSolver_Solver_LookupConstraintOrNull___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_LookupConstraintOrNull___(void *jarg1, char *jarg2)
Definition: linear_solver_csharp_wrap.cc:4128
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__AddRange
SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__AddRange(std::vector< operations_research::MPConstraint * > *self, std::vector< operations_research::MPConstraint * > const &values)
Definition: linear_solver_csharp_wrap.cc:890
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitem
SWIGINTERN std::vector< std::vector< longlong > >::value_type const & std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitem(std::vector< std::vector< int64_t > > *self, int index)
Definition: linear_solver_csharp_wrap.cc:666
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_getitem___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_getitem___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1655
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_capacity___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_capacity___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1571
std_vector_Sl_operations_research_MPVariable_Sm__Sg__Reverse__SWIG_1
SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::MPVariable * > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:1053
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_RemoveRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_RemoveRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:3717
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_reserve___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_reserve___(void *jarg1, unsigned long jarg2)
Definition: linear_solver_csharp_wrap.cc:3105
CSharp_GooglefOrToolsfLinearSolver_delete_Variable___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Variable___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4723
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_capacity___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_capacity___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2684
CSharp_GooglefOrToolsfLinearSolver_Solver_Constraint___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Constraint___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:4114
std_vector_Sl_int_Sg__setitem
SWIGINTERN void std_vector_Sl_int_Sg__setitem(std::vector< int > *self, int index, int const &val)
Definition: linear_solver_csharp_wrap.cc:349
std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveAt
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveAt(std::vector< std::vector< int > > *self, int index)
Definition: linear_solver_csharp_wrap.cc:495
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_SetRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_SetRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:2206
CSharp_GooglefOrToolsfLinearSolver_new_DoubleVector__SWIG_0___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_DoubleVector__SWIG_0___()
Definition: linear_solver_csharp_wrap.cc:2706
CSharp_GooglefOrToolsfLinearSolver_Solver_MakeBoolVar___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_MakeBoolVar___(void *jarg1, char *jarg2)
Definition: linear_solver_csharp_wrap.cc:4071
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_AddRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_AddRange___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:2044
CSharp_GooglefOrToolsfLinearSolver_Constraint_SetCoefficient___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_SetCoefficient___(void *jarg1, void *jarg2, double jarg3)
Definition: linear_solver_csharp_wrap.cc:4743
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Repeat___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Repeat___(long long jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:2157
CSharp_GooglefOrToolsfLinearSolver_new_IntVectorVector__SWIG_2___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_IntVectorVector__SWIG_2___(int jarg1)
Definition: linear_solver_csharp_wrap.cc:1619
SWIG_CSharpSetPendingException
static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg)
Definition: linear_solver_csharp_wrap.cc:226
CSharp_GooglefOrToolsfLinearSolver_Solver_Solve__SWIG_1___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Solve__SWIG_1___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:4241
CSharp_GooglefOrToolsfLinearSolver_Solver_SetHint___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SetHint___(void *jarg1, void *jarg2, int length3, double *jarg3)
Definition: linear_solver_csharp_wrap.cc:4432
CSharp_GooglefOrToolsfLinearSolver_Objective_Value___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_Value___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4577
std_vector_Sl_double_Sg__Insert
SWIGINTERN void std_vector_Sl_double_Sg__Insert(std::vector< double > *self, int index, double const &x)
Definition: linear_solver_csharp_wrap.cc:786
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__SetRange
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__SetRange(std::vector< std::vector< int64_t > > *self, int index, std::vector< std::vector< int64_t > > const &values)
Definition: linear_solver_csharp_wrap.cc:734
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Reverse__SWIG_0___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_Reverse__SWIG_0___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2595
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_getitemcopy___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_getitemcopy___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:3567
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_size___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_size___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2321
std_vector_Sl_double_Sg__IndexOf
SWIGINTERN int std_vector_Sl_double_Sg__IndexOf(std::vector< double > *self, double const &value)
Definition: linear_solver_csharp_wrap.cc:840
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_IndexOf___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_IndexOf___(void *jarg1, double jarg2)
Definition: linear_solver_csharp_wrap.cc:3005
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_GetRange___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_GetRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:3638
CSharp_GooglefOrToolsfLinearSolver_new_DoubleVector__SWIG_1___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_DoubleVector__SWIG_1___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2716
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__IndexOf
SWIGINTERN int std_vector_Sl_operations_research_MPConstraint_Sm__Sg__IndexOf(std::vector< operations_research::MPConstraint * > *self, operations_research::MPConstraint *const &value)
Definition: linear_solver_csharp_wrap.cc:956
operations_research_MPSolver_SetNumThreads
SWIGINTERN bool operations_research_MPSolver_SetNumThreads(operations_research::MPSolver *self, int num_theads)
Definition: linear_solver_csharp_wrap.cc:1120
CSharp_GooglefOrToolsfLinearSolver_IntVector_Contains___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Contains___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1465
std_vector_Sl_operations_research_MPVariable_Sm__Sg__LastIndexOf
SWIGINTERN int std_vector_Sl_operations_research_MPVariable_Sm__Sg__LastIndexOf(std::vector< operations_research::MPVariable * > *self, operations_research::MPVariable *const &value)
Definition: linear_solver_csharp_wrap.cc:1079
std_vector_Sl_int64_t_Sg__Reverse__SWIG_1
SWIGINTERN void std_vector_Sl_int64_t_Sg__Reverse__SWIG_1(std::vector< int64_t > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:609
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_getitem___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_getitem___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:2417
std_vector_Sl_int64_t_Sg__LastIndexOf
SWIGINTERN int std_vector_Sl_int64_t_Sg__LastIndexOf(std::vector< int64_t > *self, long long const &value)
Definition: linear_solver_csharp_wrap.cc:635
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__RemoveRange
SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__RemoveRange(std::vector< operations_research::MPConstraint * > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:920
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_RemoveAt___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_RemoveAt___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:3293
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_AddRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_AddRange___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:1695
CSharp_GooglefOrToolsfLinearSolver_IntVector_Reverse__SWIG_0___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Reverse__SWIG_0___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1416
std_vector_Sl_double_Sg__Reverse__SWIG_0
SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_0(std::vector< double > *self)
Definition: linear_solver_csharp_wrap.cc:818
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_GetRange___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_GetRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:2820
CSharp_GooglefOrToolsfLinearSolver_Objective_SetOffset___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_SetOffset___(void *jarg1, double jarg2)
Definition: linear_solver_csharp_wrap.cc:4505
CSharp_GooglefOrToolsfLinearSolver_new_Int64Vector__SWIG_1___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_Int64Vector__SWIG_1___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1954
CSharp_GooglefOrToolsfLinearSolver_Solver_ComputeConstraintActivities___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_ComputeConstraintActivities___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4259
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Repeat___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_Repeat___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:3737
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_LastIndexOf___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_LastIndexOf___(void *jarg1, long long jarg2)
Definition: linear_solver_csharp_wrap.cc:2259
std_vector_Sl_int_Sg__RemoveAt
SWIGINTERN void std_vector_Sl_int_Sg__RemoveAt(std::vector< int > *self, int index)
Definition: linear_solver_csharp_wrap.cc:379
std_vector_Sl_double_Sg__SetRange
SWIGINTERN void std_vector_Sl_double_Sg__SetRange(std::vector< double > *self, int index, std::vector< double > const &values)
Definition: linear_solver_csharp_wrap.cc:830
CSharp_GooglefOrToolsfLinearSolver_Variable_Ub___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_Ub___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4655
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_size___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_size___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2672
SWIGSTDCALL
#define SWIGSTDCALL
Definition: linear_solver_csharp_wrap.cc:137
std_vector_Sl_int_Sg__getitem
SWIGINTERN std::vector< int >::value_type const & std_vector_Sl_int_Sg__getitem(std::vector< int > *self, int index)
Definition: linear_solver_csharp_wrap.cc:343
CSharp_GooglefOrToolsfLinearSolver_new_MPVariableVector__SWIG_2___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_new_MPVariableVector__SWIG_2___(int jarg1)
Definition: linear_solver_csharp_wrap.cc:3550
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_1
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< int64_t > > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:725
std_vector_Sl_operations_research_MPVariable_Sm__Sg__AddRange
SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__AddRange(std::vector< operations_research::MPVariable * > *self, std::vector< operations_research::MPVariable * > const &values)
Definition: linear_solver_csharp_wrap.cc:1006
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitemcopy
SWIGINTERN std::vector< int64_t > std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitemcopy(std::vector< std::vector< int64_t > > *self, int index)
Definition: linear_solver_csharp_wrap.cc:660
CSharp_GooglefOrToolsfLinearSolver_Objective_GetCoefficient___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_GetCoefficient___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:4491
CSharp_GooglefOrToolsfLinearSolver_Variable_Lb___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_Lb___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4643
std_vector_Sl_int_Sg__IndexOf
SWIGINTERN int std_vector_Sl_int_Sg__IndexOf(std::vector< int > *self, int const &value)
Definition: linear_solver_csharp_wrap.cc:421
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__getitem
SWIGINTERN std::vector< operations_research::MPConstraint * >::value_type const & std_vector_Sl_operations_research_MPConstraint_Sm__Sg__getitem(std::vector< operations_research::MPConstraint * > *self, int index)
Definition: linear_solver_csharp_wrap.cc:878
CSharp_GooglefOrToolsfLinearSolver_IntVector_Reverse__SWIG_1___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_Reverse__SWIG_1___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:1424
CSharp_GooglefOrToolsfLinearSolver_delete_MPVariableVector___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_MPVariableVector___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:3871
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_SetRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_SetRange___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:3377
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Insert___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_Insert___(void *jarg1, int jarg2, void *jarg3)
Definition: linear_solver_csharp_wrap.cc:1733
CSharp_GooglefOrToolsfLinearSolver_IntVector_getitem___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVector_getitem___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1244
CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Remove___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_DoubleVector_Remove___(void *jarg1, double jarg2)
Definition: linear_solver_csharp_wrap.cc:3037
std_vector_Sl_double_Sg__Contains
SWIGINTERN bool std_vector_Sl_double_Sg__Contains(std::vector< double > *self, double const &value)
Definition: linear_solver_csharp_wrap.cc:837
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_GetRange___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_GetRange___(void *jarg1, int jarg2, int jarg3)
Definition: linear_solver_csharp_wrap.cc:3229
std_vector_Sl_int64_t_Sg__RemoveRange
SWIGINTERN void std_vector_Sl_int64_t_Sg__RemoveRange(std::vector< int64_t > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:592
std_vector_Sl_int_Sg__SetRange
SWIGINTERN void std_vector_Sl_int_Sg__SetRange(std::vector< int > *self, int index, std::vector< int > const &values)
Definition: linear_solver_csharp_wrap.cc:411
SWIGEXPORT
#define SWIGEXPORT
Definition: linear_solver_csharp_wrap.cc:127
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_AddRange___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_AddRange___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3215
CSharp_GooglefOrToolsfLinearSolver_Solver_Variable___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_Variable___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:3967
std_vector_Sl_operations_research_MPVariable_Sm__Sg__InsertRange
SWIGINTERN void std_vector_Sl_operations_research_MPVariable_Sm__Sg__InsertRange(std::vector< operations_research::MPVariable * > *self, int index, std::vector< operations_research::MPVariable * > const &values)
Definition: linear_solver_csharp_wrap.cc:1024
std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__setitem
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__setitem(std::vector< std::vector< int64_t > > *self, int index, std::vector< int64_t > const &val)
Definition: linear_solver_csharp_wrap.cc:672
CSharp_GooglefOrToolsfLinearSolver_Solver_NumConstraints___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_NumConstraints___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4090
std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitem
SWIGINTERN std::vector< std::vector< int > >::value_type const & std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitem(std::vector< std::vector< int > > *self, int index)
Definition: linear_solver_csharp_wrap.cc:459
CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_RemoveAt___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_IntVectorVector_RemoveAt___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:1775
std_vector_Sl_int64_t_Sg__RemoveAt
SWIGINTERN void std_vector_Sl_int64_t_Sg__RemoveAt(std::vector< int64_t > *self, int index)
Definition: linear_solver_csharp_wrap.cc:586
CSharp_GooglefOrToolsfLinearSolver_Variable_SetBounds___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Variable_SetBounds___(void *jarg1, double jarg2, double jarg3)
Definition: linear_solver_csharp_wrap.cc:4687
std_vector_Sl_int64_t_Sg__IndexOf
SWIGINTERN int std_vector_Sl_int64_t_Sg__IndexOf(std::vector< int64_t > *self, long long const &value)
Definition: linear_solver_csharp_wrap.cc:628
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Insert___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_Insert___(void *jarg1, int jarg2, long long jarg3)
Definition: linear_solver_csharp_wrap.cc:2082
CSharp_GooglefOrToolsfLinearSolver_Objective_Clear___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Objective_Clear___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4471
CSharp_GooglefOrToolsfLinearSolver_Solver_SetSolverSpecificParametersAsString___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_SetSolverSpecificParametersAsString___(void *jarg1, char *jarg2)
Definition: linear_solver_csharp_wrap.cc:4309
CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultIncrementality_get___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultIncrementality_get___()
Definition: linear_solver_csharp_wrap.cc:4931
CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_RemoveAt___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64VectorVector_RemoveAt___(void *jarg1, int jarg2)
Definition: linear_solver_csharp_wrap.cc:2537
SWIG_CSharpExceptionCodes
SWIG_CSharpExceptionCodes
Definition: linear_solver_csharp_wrap.cc:173
SWIG_CSharpDivideByZeroException
@ SWIG_CSharpDivideByZeroException
Definition: linear_solver_csharp_wrap.cc:176
SWIG_CSharpOutOfMemoryException
@ SWIG_CSharpOutOfMemoryException
Definition: linear_solver_csharp_wrap.cc:182
SWIG_CSharpArithmeticException
@ SWIG_CSharpArithmeticException
Definition: linear_solver_csharp_wrap.cc:175
SWIG_CSharpSystemException
@ SWIG_CSharpSystemException
Definition: linear_solver_csharp_wrap.cc:184
SWIG_CSharpApplicationException
@ SWIG_CSharpApplicationException
Definition: linear_solver_csharp_wrap.cc:174
SWIG_CSharpNullReferenceException
@ SWIG_CSharpNullReferenceException
Definition: linear_solver_csharp_wrap.cc:181
SWIG_CSharpInvalidCastException
@ SWIG_CSharpInvalidCastException
Definition: linear_solver_csharp_wrap.cc:178
SWIG_CSharpInvalidOperationException
@ SWIG_CSharpInvalidOperationException
Definition: linear_solver_csharp_wrap.cc:179
SWIG_CSharpOverflowException
@ SWIG_CSharpOverflowException
Definition: linear_solver_csharp_wrap.cc:183
SWIG_CSharpIOException
@ SWIG_CSharpIOException
Definition: linear_solver_csharp_wrap.cc:180
SWIG_CSharpIndexOutOfRangeException
@ SWIG_CSharpIndexOutOfRangeException
Definition: linear_solver_csharp_wrap.cc:177
CSharp_GooglefOrToolsfLinearSolver_Constraint_Name___
SWIGEXPORT char *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_Name___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4731
CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_LastIndexOf___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPVariableVector_LastIndexOf___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3839
operations_research_MPSolver_ExportModelAsMpsFormat
SWIGINTERN std::string operations_research_MPSolver_ExportModelAsMpsFormat(operations_research::MPSolver *self, bool fixed_format, bool obfuscated)
Definition: linear_solver_csharp_wrap.cc:1101
CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultPresolve_get___
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPSolverParameters_kDefaultPresolve_get___()
Definition: linear_solver_csharp_wrap.cc:4921
CSharp_GooglefOrToolsfLinearSolver_delete_Int64Vector___
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_delete_Int64Vector___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:2291
std_vector_Sl_int_Sg__Insert
SWIGINTERN void std_vector_Sl_int_Sg__Insert(std::vector< int > *self, int index, int const &x)
Definition: linear_solver_csharp_wrap.cc:367
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__GetRange
SWIGINTERN std::vector< operations_research::MPConstraint * > * std_vector_Sl_operations_research_MPConstraint_Sm__Sg__GetRange(std::vector< operations_research::MPConstraint * > *self, int index, int count)
Definition: linear_solver_csharp_wrap.cc:893
std_vector_Sl_std_vector_Sl_int_Sg__Sg__AddRange
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__AddRange(std::vector< std::vector< int > > *self, std::vector< std::vector< int > > const &values)
Definition: linear_solver_csharp_wrap.cc:471
std_vector_Sl_operations_research_MPConstraint_Sm__Sg__RemoveAt
SWIGINTERN void std_vector_Sl_operations_research_MPConstraint_Sm__Sg__RemoveAt(std::vector< operations_research::MPConstraint * > *self, int index)
Definition: linear_solver_csharp_wrap.cc:914
CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Remove___
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_MPConstraintVector_Remove___(void *jarg1, void *jarg2)
Definition: linear_solver_csharp_wrap.cc:3446
CSharp_GooglefOrToolsfLinearSolver_Solver_CreateSolver___
SWIGEXPORT void *SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Solver_CreateSolver___(char *jarg1)
Definition: linear_solver_csharp_wrap.cc:3906
CSharp_GooglefOrToolsfLinearSolver_Constraint_Lb___
SWIGEXPORT double SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Constraint_Lb___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:4769
CSharp_GooglefOrToolsfLinearSolver_Int64Vector_size___
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfLinearSolver_Int64Vector_size___(void *jarg1)
Definition: linear_solver_csharp_wrap.cc:1910
FATAL
const int FATAL
Definition: log_severity.h:32
model_exporter.h
operations_research::math_opt::NumVariables
int NumVariables(const VariablesProto &variables)
Definition: math_opt_proto_utils.h:32
operations_research::math_opt::NumConstraints
int NumConstraints(const LinearConstraintsProto &linear_constraints)
Definition: math_opt_proto_utils.h:36
operations_research::sat::GetCoefficient
IntegerValue GetCoefficient(const IntegerVariable var, const LinearExpression &expr)
Definition: linear_constraint.cc:419
operations_research::sat::Value
std::function< int64_t(const Model &)> Value(IntegerVariable v)
Definition: integer.h:1673
operations_research::ExportModelAsMpsFormat
absl::StatusOr< std::string > ExportModelAsMpsFormat(const MPModelProto &model, const MPModelExportOptions &options)
Outputs the current model (variables, constraints, objective) as a string encoded in MPS file format,...
Definition: model_exporter.cc:230
operations_research::ExportModelAsLpFormat
absl::StatusOr< std::string > ExportModelAsLpFormat(const MPModelProto &model, const MPModelExportOptions &options)
Outputs the current model (variables, constraints, objective) as a string encoded in the so-called "C...
Definition: model_exporter.cc:213
index
int index
Definition: pack.cc:509
capacity
int64_t capacity
Definition: routing_flow.cc:151
nodes
int nodes
Definition: routing_search.cc:3866
SWIG_CSharpException_t
Definition: knapsack_solver_csharp_wrap.cc:196
SWIG_CSharpException_t::callback
SWIG_CSharpExceptionCallback_t callback
Definition: knapsack_solver_csharp_wrap.cc:198
SWIG_CSharpExceptionArgument_t
Definition: knapsack_solver_csharp_wrap.cc:201
SWIG_CSharpExceptionArgument_t::callback
SWIG_CSharpExceptionArgumentCallback_t callback
Definition: knapsack_solver_csharp_wrap.cc:203
operations_research::MPModelExportOptions
Export options.
Definition: model_exporter.h:29
operations_research::MPModelExportOptions::obfuscate
bool obfuscate
Obfuscates variable and constraint names.
Definition: model_exporter.h:33