00001
00002
00003
00004
00005
00006
00007
00008 from sys import version_info
00009 if version_info >= (2,6,0):
00010 def swig_import_helper():
00011 from os.path import dirname
00012 import imp
00013 fp = None
00014 try:
00015 fp, pathname, description = imp.find_module('_SyFi', [dirname(__file__)])
00016 except ImportError:
00017 import _SyFi
00018 return _SyFi
00019 if fp is not None:
00020 try:
00021 _mod = imp.load_module('_SyFi', fp, pathname, description)
00022 finally:
00023 fp.close()
00024 return _mod
00025 _SyFi = swig_import_helper()
00026 del swig_import_helper
00027 else:
00028 import _SyFi
00029 del version_info
00030 try:
00031 _swig_property = property
00032 except NameError:
00033 pass
00034 def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
00035 if (name == "thisown"): return self.this.own(value)
00036 if (name == "this"):
00037 if type(value).__name__ == 'SwigPyObject':
00038 self.__dict__[name] = value
00039 return
00040 method = class_type.__swig_setmethods__.get(name,None)
00041 if method: return method(self,value)
00042 if (not static) or hasattr(self,name):
00043 self.__dict__[name] = value
00044 else:
00045 raise AttributeError("You cannot add attributes to %s" % self)
00046
00047 def _swig_setattr(self,class_type,name,value):
00048 return _swig_setattr_nondynamic(self,class_type,name,value,0)
00049
00050 def _swig_getattr(self,class_type,name):
00051 if (name == "thisown"): return self.this.own()
00052 method = class_type.__swig_getmethods__.get(name,None)
00053 if method: return method(self)
00054 raise AttributeError(name)
00055
00056 def _swig_repr(self):
00057 try: strthis = "proxy of " + self.this.__repr__()
00058 except: strthis = ""
00059 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
00060
00061 try:
00062 _object = object
00063 _newclass = 1
00064 except AttributeError:
00065 class _object : pass
00066 _newclass = 0
00067
00068
00069
00070 def setDigits(*args):
00071 """setDigits(int a)"""
00072 return _SyFi.setDigits(*args)
00073 GINACLIB_MAJOR_VERSION = _SyFi.GINACLIB_MAJOR_VERSION
00074 GINACLIB_MINOR_VERSION = _SyFi.GINACLIB_MINOR_VERSION
00075 GINACLIB_MICRO_VERSION = _SyFi.GINACLIB_MICRO_VERSION
00076 class SwigPyIterator(_object):
00077 """Proxy of C++ swig::SwigPyIterator class"""
00078 __swig_setmethods__ = {}
00079 __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
00080 __swig_getmethods__ = {}
00081 __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
00082 def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
00083 __repr__ = _swig_repr
00084 __swig_destroy__ = _SyFi.delete_SwigPyIterator
00085 __del__ = lambda self : None;
00086 def value(self):
00087 """value(self) -> PyObject"""
00088 return _SyFi.SwigPyIterator_value(self)
00089
00090 def incr(self, n = 1):
00091 """
00092 incr(self, size_t n = 1) -> SwigPyIterator
00093 incr(self) -> SwigPyIterator
00094 """
00095 return _SyFi.SwigPyIterator_incr(self, n)
00096
00097 def decr(self, n = 1):
00098 """
00099 decr(self, size_t n = 1) -> SwigPyIterator
00100 decr(self) -> SwigPyIterator
00101 """
00102 return _SyFi.SwigPyIterator_decr(self, n)
00103
00104 def distance(self, *args):
00105 """distance(self, SwigPyIterator x) -> ptrdiff_t"""
00106 return _SyFi.SwigPyIterator_distance(self, *args)
00107
00108 def equal(self, *args):
00109 """equal(self, SwigPyIterator x) -> bool"""
00110 return _SyFi.SwigPyIterator_equal(self, *args)
00111
00112 def copy(self):
00113 """copy(self) -> SwigPyIterator"""
00114 return _SyFi.SwigPyIterator_copy(self)
00115
00116 def next(self):
00117 """next(self) -> PyObject"""
00118 return _SyFi.SwigPyIterator_next(self)
00119
00120 def __next__(self):
00121 """__next__(self) -> PyObject"""
00122 return _SyFi.SwigPyIterator___next__(self)
00123
00124 def previous(self):
00125 """previous(self) -> PyObject"""
00126 return _SyFi.SwigPyIterator_previous(self)
00127
00128 def advance(self, *args):
00129 """advance(self, ptrdiff_t n) -> SwigPyIterator"""
00130 return _SyFi.SwigPyIterator_advance(self, *args)
00131
00132 def __eq__(self, *args):
00133 """__eq__(self, SwigPyIterator x) -> bool"""
00134 return _SyFi.SwigPyIterator___eq__(self, *args)
00135
00136 def __ne__(self, *args):
00137 """__ne__(self, SwigPyIterator x) -> bool"""
00138 return _SyFi.SwigPyIterator___ne__(self, *args)
00139
00140 def __iadd__(self, *args):
00141 """__iadd__(self, ptrdiff_t n) -> SwigPyIterator"""
00142 return _SyFi.SwigPyIterator___iadd__(self, *args)
00143
00144 def __isub__(self, *args):
00145 """__isub__(self, ptrdiff_t n) -> SwigPyIterator"""
00146 return _SyFi.SwigPyIterator___isub__(self, *args)
00147
00148 def __add__(self, *args):
00149 """__add__(self, ptrdiff_t n) -> SwigPyIterator"""
00150 return _SyFi.SwigPyIterator___add__(self, *args)
00151
00152 def __sub__(self, *args):
00153 """
00154 __sub__(self, ptrdiff_t n) -> SwigPyIterator
00155 __sub__(self, SwigPyIterator x) -> ptrdiff_t
00156 """
00157 return _SyFi.SwigPyIterator___sub__(self, *args)
00158
00159 def __iter__(self): return self
00160 SwigPyIterator_swigregister = _SyFi.SwigPyIterator_swigregister
00161 SwigPyIterator_swigregister(SwigPyIterator)
00162
00163 class exvector(_object):
00164 """Proxy of C++ std::vector<(GiNaC::ex)> class"""
00165 __swig_setmethods__ = {}
00166 __setattr__ = lambda self, name, value: _swig_setattr(self, exvector, name, value)
00167 __swig_getmethods__ = {}
00168 __getattr__ = lambda self, name: _swig_getattr(self, exvector, name)
00169 __repr__ = _swig_repr
00170 def iterator(self):
00171 """iterator(self) -> SwigPyIterator"""
00172 return _SyFi.exvector_iterator(self)
00173
00174 def __iter__(self): return self.iterator()
00175 def __nonzero__(self):
00176 """__nonzero__(self) -> bool"""
00177 return _SyFi.exvector___nonzero__(self)
00178
00179 def __bool__(self):
00180 """__bool__(self) -> bool"""
00181 return _SyFi.exvector___bool__(self)
00182
00183 def __len__(self):
00184 """__len__(self) -> size_type"""
00185 return _SyFi.exvector___len__(self)
00186
00187 def pop(self):
00188 """pop(self) -> value_type"""
00189 return _SyFi.exvector_pop(self)
00190
00191 def __getslice__(self, *args):
00192 """__getslice__(self, difference_type i, difference_type j) -> exvector"""
00193 return _SyFi.exvector___getslice__(self, *args)
00194
00195 def __setslice__(self, *args):
00196 """__setslice__(self, difference_type i, difference_type j, exvector v)"""
00197 return _SyFi.exvector___setslice__(self, *args)
00198
00199 def __delslice__(self, *args):
00200 """__delslice__(self, difference_type i, difference_type j)"""
00201 return _SyFi.exvector___delslice__(self, *args)
00202
00203 def __delitem__(self, *args):
00204 """
00205 __delitem__(self, difference_type i)
00206 __delitem__(self, PySliceObject slice)
00207 """
00208 return _SyFi.exvector___delitem__(self, *args)
00209
00210 def __getitem__(self, *args):
00211 """
00212 __getitem__(self, PySliceObject slice) -> exvector
00213 __getitem__(self, difference_type i) -> value_type
00214 """
00215 return _SyFi.exvector___getitem__(self, *args)
00216
00217 def __setitem__(self, *args):
00218 """
00219 __setitem__(self, PySliceObject slice, exvector v)
00220 __setitem__(self, difference_type i, value_type x)
00221 """
00222 return _SyFi.exvector___setitem__(self, *args)
00223
00224 def append(self, *args):
00225 """append(self, value_type x)"""
00226 return _SyFi.exvector_append(self, *args)
00227
00228 def empty(self):
00229 """empty(self) -> bool"""
00230 return _SyFi.exvector_empty(self)
00231
00232 def size(self):
00233 """size(self) -> size_type"""
00234 return _SyFi.exvector_size(self)
00235
00236 def clear(self):
00237 """clear(self)"""
00238 return _SyFi.exvector_clear(self)
00239
00240 def swap(self, *args):
00241 """swap(self, exvector v)"""
00242 return _SyFi.exvector_swap(self, *args)
00243
00244 def get_allocator(self):
00245 """get_allocator(self) -> allocator_type"""
00246 return _SyFi.exvector_get_allocator(self)
00247
00248 def begin(self):
00249 """begin(self) -> const_iterator"""
00250 return _SyFi.exvector_begin(self)
00251
00252 def end(self):
00253 """end(self) -> const_iterator"""
00254 return _SyFi.exvector_end(self)
00255
00256 def rbegin(self):
00257 """rbegin(self) -> const_reverse_iterator"""
00258 return _SyFi.exvector_rbegin(self)
00259
00260 def rend(self):
00261 """rend(self) -> const_reverse_iterator"""
00262 return _SyFi.exvector_rend(self)
00263
00264 def pop_back(self):
00265 """pop_back(self)"""
00266 return _SyFi.exvector_pop_back(self)
00267
00268 def erase(self, *args):
00269 """
00270 erase(self, iterator pos) -> iterator
00271 erase(self, iterator first, iterator last) -> iterator
00272 """
00273 return _SyFi.exvector_erase(self, *args)
00274
00275 def __init__(self, *args):
00276 """
00277 __init__(self) -> exvector
00278 __init__(self, exvector arg0) -> exvector
00279 __init__(self, size_type size) -> exvector
00280 __init__(self, size_type size, value_type value) -> exvector
00281 """
00282 this = _SyFi.new_exvector(*args)
00283 try: self.this.append(this)
00284 except: self.this = this
00285 def push_back(self, *args):
00286 """push_back(self, value_type x)"""
00287 return _SyFi.exvector_push_back(self, *args)
00288
00289 def front(self):
00290 """front(self) -> value_type"""
00291 return _SyFi.exvector_front(self)
00292
00293 def back(self):
00294 """back(self) -> value_type"""
00295 return _SyFi.exvector_back(self)
00296
00297 def assign(self, *args):
00298 """assign(self, size_type n, value_type x)"""
00299 return _SyFi.exvector_assign(self, *args)
00300
00301 def resize(self, *args):
00302 """
00303 resize(self, size_type new_size)
00304 resize(self, size_type new_size, value_type x)
00305 """
00306 return _SyFi.exvector_resize(self, *args)
00307
00308 def insert(self, *args):
00309 """
00310 insert(self, iterator pos, value_type x) -> iterator
00311 insert(self, iterator pos, size_type n, value_type x)
00312 """
00313 return _SyFi.exvector_insert(self, *args)
00314
00315 def reserve(self, *args):
00316 """reserve(self, size_type n)"""
00317 return _SyFi.exvector_reserve(self, *args)
00318
00319 def capacity(self):
00320 """capacity(self) -> size_type"""
00321 return _SyFi.exvector_capacity(self)
00322
00323 __swig_destroy__ = _SyFi.delete_exvector
00324 __del__ = lambda self : None;
00325 exvector_swigregister = _SyFi.exvector_swigregister
00326 exvector_swigregister(exvector)
00327
00328 class exmap(_object):
00329 """Proxy of C++ std::map<(GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less)> class"""
00330 __swig_setmethods__ = {}
00331 __setattr__ = lambda self, name, value: _swig_setattr(self, exmap, name, value)
00332 __swig_getmethods__ = {}
00333 __getattr__ = lambda self, name: _swig_getattr(self, exmap, name)
00334 __repr__ = _swig_repr
00335 def iterator(self):
00336 """iterator(self) -> SwigPyIterator"""
00337 return _SyFi.exmap_iterator(self)
00338
00339 def __iter__(self): return self.iterator()
00340 def __nonzero__(self):
00341 """__nonzero__(self) -> bool"""
00342 return _SyFi.exmap___nonzero__(self)
00343
00344 def __bool__(self):
00345 """__bool__(self) -> bool"""
00346 return _SyFi.exmap___bool__(self)
00347
00348 def __len__(self):
00349 """__len__(self) -> size_type"""
00350 return _SyFi.exmap___len__(self)
00351
00352 def __getitem__(self, *args):
00353 """__getitem__(self, key_type key) -> mapped_type"""
00354 return _SyFi.exmap___getitem__(self, *args)
00355
00356 def __delitem__(self, *args):
00357 """__delitem__(self, key_type key)"""
00358 return _SyFi.exmap___delitem__(self, *args)
00359
00360 def has_key(self, *args):
00361 """has_key(self, key_type key) -> bool"""
00362 return _SyFi.exmap_has_key(self, *args)
00363
00364 def keys(self):
00365 """keys(self) -> PyObject"""
00366 return _SyFi.exmap_keys(self)
00367
00368 def values(self):
00369 """values(self) -> PyObject"""
00370 return _SyFi.exmap_values(self)
00371
00372 def items(self):
00373 """items(self) -> PyObject"""
00374 return _SyFi.exmap_items(self)
00375
00376 def __contains__(self, *args):
00377 """__contains__(self, key_type key) -> bool"""
00378 return _SyFi.exmap___contains__(self, *args)
00379
00380 def key_iterator(self):
00381 """key_iterator(self) -> SwigPyIterator"""
00382 return _SyFi.exmap_key_iterator(self)
00383
00384 def value_iterator(self):
00385 """value_iterator(self) -> SwigPyIterator"""
00386 return _SyFi.exmap_value_iterator(self)
00387
00388 def __iter__(self): return self.key_iterator()
00389 def iterkeys(self): return self.key_iterator()
00390 def itervalues(self): return self.value_iterator()
00391 def iteritems(self): return self.iterator()
00392 def __setitem__(self, *args):
00393 """__setitem__(self, key_type key, mapped_type x)"""
00394 return _SyFi.exmap___setitem__(self, *args)
00395
00396 def __init__(self, *args):
00397 """
00398 __init__(self, GiNaC::ex_is_less arg0) -> exmap
00399 __init__(self) -> exmap
00400 __init__(self, exmap arg0) -> exmap
00401 """
00402 this = _SyFi.new_exmap(*args)
00403 try: self.this.append(this)
00404 except: self.this = this
00405 def empty(self):
00406 """empty(self) -> bool"""
00407 return _SyFi.exmap_empty(self)
00408
00409 def size(self):
00410 """size(self) -> size_type"""
00411 return _SyFi.exmap_size(self)
00412
00413 def clear(self):
00414 """clear(self)"""
00415 return _SyFi.exmap_clear(self)
00416
00417 def swap(self, *args):
00418 """swap(self, exmap v)"""
00419 return _SyFi.exmap_swap(self, *args)
00420
00421 def get_allocator(self):
00422 """get_allocator(self) -> allocator_type"""
00423 return _SyFi.exmap_get_allocator(self)
00424
00425 def begin(self):
00426 """begin(self) -> const_iterator"""
00427 return _SyFi.exmap_begin(self)
00428
00429 def end(self):
00430 """end(self) -> const_iterator"""
00431 return _SyFi.exmap_end(self)
00432
00433 def rbegin(self):
00434 """rbegin(self) -> const_reverse_iterator"""
00435 return _SyFi.exmap_rbegin(self)
00436
00437 def rend(self):
00438 """rend(self) -> const_reverse_iterator"""
00439 return _SyFi.exmap_rend(self)
00440
00441 def count(self, *args):
00442 """count(self, key_type x) -> size_type"""
00443 return _SyFi.exmap_count(self, *args)
00444
00445 def erase(self, *args):
00446 """
00447 erase(self, key_type x) -> size_type
00448 erase(self, iterator position)
00449 erase(self, iterator first, iterator last)
00450 """
00451 return _SyFi.exmap_erase(self, *args)
00452
00453 def find(self, *args):
00454 """find(self, key_type x) -> iterator"""
00455 return _SyFi.exmap_find(self, *args)
00456
00457 def lower_bound(self, *args):
00458 """lower_bound(self, key_type x) -> iterator"""
00459 return _SyFi.exmap_lower_bound(self, *args)
00460
00461 def upper_bound(self, *args):
00462 """upper_bound(self, key_type x) -> iterator"""
00463 return _SyFi.exmap_upper_bound(self, *args)
00464
00465 __swig_destroy__ = _SyFi.delete_exmap
00466 __del__ = lambda self : None;
00467 exmap_swigregister = _SyFi.exmap_swigregister
00468 exmap_swigregister(exmap)
00469
00470 class ex_int_map(_object):
00471 """Proxy of C++ std::map<(GiNaC::ex,int,GiNaC::ex_is_less)> class"""
00472 __swig_setmethods__ = {}
00473 __setattr__ = lambda self, name, value: _swig_setattr(self, ex_int_map, name, value)
00474 __swig_getmethods__ = {}
00475 __getattr__ = lambda self, name: _swig_getattr(self, ex_int_map, name)
00476 __repr__ = _swig_repr
00477 def iterator(self):
00478 """iterator(self) -> SwigPyIterator"""
00479 return _SyFi.ex_int_map_iterator(self)
00480
00481 def __iter__(self): return self.iterator()
00482 def __nonzero__(self):
00483 """__nonzero__(self) -> bool"""
00484 return _SyFi.ex_int_map___nonzero__(self)
00485
00486 def __bool__(self):
00487 """__bool__(self) -> bool"""
00488 return _SyFi.ex_int_map___bool__(self)
00489
00490 def __len__(self):
00491 """__len__(self) -> size_type"""
00492 return _SyFi.ex_int_map___len__(self)
00493
00494 def __getitem__(self, *args):
00495 """__getitem__(self, key_type key) -> mapped_type"""
00496 return _SyFi.ex_int_map___getitem__(self, *args)
00497
00498 def __delitem__(self, *args):
00499 """__delitem__(self, key_type key)"""
00500 return _SyFi.ex_int_map___delitem__(self, *args)
00501
00502 def has_key(self, *args):
00503 """has_key(self, key_type key) -> bool"""
00504 return _SyFi.ex_int_map_has_key(self, *args)
00505
00506 def keys(self):
00507 """keys(self) -> PyObject"""
00508 return _SyFi.ex_int_map_keys(self)
00509
00510 def values(self):
00511 """values(self) -> PyObject"""
00512 return _SyFi.ex_int_map_values(self)
00513
00514 def items(self):
00515 """items(self) -> PyObject"""
00516 return _SyFi.ex_int_map_items(self)
00517
00518 def __contains__(self, *args):
00519 """__contains__(self, key_type key) -> bool"""
00520 return _SyFi.ex_int_map___contains__(self, *args)
00521
00522 def key_iterator(self):
00523 """key_iterator(self) -> SwigPyIterator"""
00524 return _SyFi.ex_int_map_key_iterator(self)
00525
00526 def value_iterator(self):
00527 """value_iterator(self) -> SwigPyIterator"""
00528 return _SyFi.ex_int_map_value_iterator(self)
00529
00530 def __iter__(self): return self.key_iterator()
00531 def iterkeys(self): return self.key_iterator()
00532 def itervalues(self): return self.value_iterator()
00533 def iteritems(self): return self.iterator()
00534 def __setitem__(self, *args):
00535 """__setitem__(self, key_type key, mapped_type x)"""
00536 return _SyFi.ex_int_map___setitem__(self, *args)
00537
00538 def __init__(self, *args):
00539 """
00540 __init__(self, GiNaC::ex_is_less arg0) -> ex_int_map
00541 __init__(self) -> ex_int_map
00542 __init__(self, ex_int_map arg0) -> ex_int_map
00543 """
00544 this = _SyFi.new_ex_int_map(*args)
00545 try: self.this.append(this)
00546 except: self.this = this
00547 def empty(self):
00548 """empty(self) -> bool"""
00549 return _SyFi.ex_int_map_empty(self)
00550
00551 def size(self):
00552 """size(self) -> size_type"""
00553 return _SyFi.ex_int_map_size(self)
00554
00555 def clear(self):
00556 """clear(self)"""
00557 return _SyFi.ex_int_map_clear(self)
00558
00559 def swap(self, *args):
00560 """swap(self, ex_int_map v)"""
00561 return _SyFi.ex_int_map_swap(self, *args)
00562
00563 def get_allocator(self):
00564 """get_allocator(self) -> allocator_type"""
00565 return _SyFi.ex_int_map_get_allocator(self)
00566
00567 def begin(self):
00568 """begin(self) -> const_iterator"""
00569 return _SyFi.ex_int_map_begin(self)
00570
00571 def end(self):
00572 """end(self) -> const_iterator"""
00573 return _SyFi.ex_int_map_end(self)
00574
00575 def rbegin(self):
00576 """rbegin(self) -> const_reverse_iterator"""
00577 return _SyFi.ex_int_map_rbegin(self)
00578
00579 def rend(self):
00580 """rend(self) -> const_reverse_iterator"""
00581 return _SyFi.ex_int_map_rend(self)
00582
00583 def count(self, *args):
00584 """count(self, key_type x) -> size_type"""
00585 return _SyFi.ex_int_map_count(self, *args)
00586
00587 def erase(self, *args):
00588 """
00589 erase(self, key_type x) -> size_type
00590 erase(self, iterator position)
00591 erase(self, iterator first, iterator last)
00592 """
00593 return _SyFi.ex_int_map_erase(self, *args)
00594
00595 def find(self, *args):
00596 """find(self, key_type x) -> iterator"""
00597 return _SyFi.ex_int_map_find(self, *args)
00598
00599 def lower_bound(self, *args):
00600 """lower_bound(self, key_type x) -> iterator"""
00601 return _SyFi.ex_int_map_lower_bound(self, *args)
00602
00603 def upper_bound(self, *args):
00604 """upper_bound(self, key_type x) -> iterator"""
00605 return _SyFi.ex_int_map_upper_bound(self, *args)
00606
00607 __swig_destroy__ = _SyFi.delete_ex_int_map
00608 __del__ = lambda self : None;
00609 ex_int_map_swigregister = _SyFi.ex_int_map_swigregister
00610 ex_int_map_swigregister(ex_int_map)
00611
00612 class symexpair(_object):
00613 """Proxy of C++ std::pair<(GiNaC::symbol,GiNaC::ex)> class"""
00614 __swig_setmethods__ = {}
00615 __setattr__ = lambda self, name, value: _swig_setattr(self, symexpair, name, value)
00616 __swig_getmethods__ = {}
00617 __getattr__ = lambda self, name: _swig_getattr(self, symexpair, name)
00618 __repr__ = _swig_repr
00619 def __init__(self, *args):
00620 """
00621 __init__(self) -> symexpair
00622 __init__(self, GiNaC::symbol first, GiNaC::ex second) -> symexpair
00623 __init__(self, symexpair p) -> symexpair
00624 """
00625 this = _SyFi.new_symexpair(*args)
00626 try: self.this.append(this)
00627 except: self.this = this
00628 __swig_setmethods__["first"] = _SyFi.symexpair_first_set
00629 __swig_getmethods__["first"] = _SyFi.symexpair_first_get
00630 if _newclass:first = _swig_property(_SyFi.symexpair_first_get, _SyFi.symexpair_first_set)
00631 __swig_setmethods__["second"] = _SyFi.symexpair_second_set
00632 __swig_getmethods__["second"] = _SyFi.symexpair_second_get
00633 if _newclass:second = _swig_property(_SyFi.symexpair_second_get, _SyFi.symexpair_second_set)
00634 def __len__(self): return 2
00635 def __repr__(self): return str((self.first, self.second))
00636 def __getitem__(self, index):
00637 if not (index % 2):
00638 return self.first
00639 else:
00640 return self.second
00641 def __setitem__(self, index, val):
00642 if not (index % 2):
00643 self.first = val
00644 else:
00645 self.second = val
00646 __swig_destroy__ = _SyFi.delete_symexpair
00647 __del__ = lambda self : None;
00648 symexpair_swigregister = _SyFi.symexpair_swigregister
00649 symexpair_swigregister(symexpair)
00650
00651 class symexlist(_object):
00652 """Proxy of C++ std::list<(std::pair<(GiNaC::symbol,GiNaC::ex)>)> class"""
00653 __swig_setmethods__ = {}
00654 __setattr__ = lambda self, name, value: _swig_setattr(self, symexlist, name, value)
00655 __swig_getmethods__ = {}
00656 __getattr__ = lambda self, name: _swig_getattr(self, symexlist, name)
00657 __repr__ = _swig_repr
00658 def iterator(self):
00659 """iterator(self) -> SwigPyIterator"""
00660 return _SyFi.symexlist_iterator(self)
00661
00662 def __iter__(self): return self.iterator()
00663 def __nonzero__(self):
00664 """__nonzero__(self) -> bool"""
00665 return _SyFi.symexlist___nonzero__(self)
00666
00667 def __bool__(self):
00668 """__bool__(self) -> bool"""
00669 return _SyFi.symexlist___bool__(self)
00670
00671 def __len__(self):
00672 """__len__(self) -> size_type"""
00673 return _SyFi.symexlist___len__(self)
00674
00675 def pop(self):
00676 """pop(self) -> value_type"""
00677 return _SyFi.symexlist_pop(self)
00678
00679 def __getslice__(self, *args):
00680 """__getslice__(self, difference_type i, difference_type j) -> symexlist"""
00681 return _SyFi.symexlist___getslice__(self, *args)
00682
00683 def __setslice__(self, *args):
00684 """__setslice__(self, difference_type i, difference_type j, symexlist v)"""
00685 return _SyFi.symexlist___setslice__(self, *args)
00686
00687 def __delslice__(self, *args):
00688 """__delslice__(self, difference_type i, difference_type j)"""
00689 return _SyFi.symexlist___delslice__(self, *args)
00690
00691 def __delitem__(self, *args):
00692 """
00693 __delitem__(self, difference_type i)
00694 __delitem__(self, PySliceObject slice)
00695 """
00696 return _SyFi.symexlist___delitem__(self, *args)
00697
00698 def __getitem__(self, *args):
00699 """
00700 __getitem__(self, PySliceObject slice) -> symexlist
00701 __getitem__(self, difference_type i) -> value_type
00702 """
00703 return _SyFi.symexlist___getitem__(self, *args)
00704
00705 def __setitem__(self, *args):
00706 """
00707 __setitem__(self, PySliceObject slice, symexlist v)
00708 __setitem__(self, difference_type i, value_type x)
00709 """
00710 return _SyFi.symexlist___setitem__(self, *args)
00711
00712 def append(self, *args):
00713 """append(self, value_type x)"""
00714 return _SyFi.symexlist_append(self, *args)
00715
00716 def empty(self):
00717 """empty(self) -> bool"""
00718 return _SyFi.symexlist_empty(self)
00719
00720 def size(self):
00721 """size(self) -> size_type"""
00722 return _SyFi.symexlist_size(self)
00723
00724 def clear(self):
00725 """clear(self)"""
00726 return _SyFi.symexlist_clear(self)
00727
00728 def swap(self, *args):
00729 """swap(self, symexlist v)"""
00730 return _SyFi.symexlist_swap(self, *args)
00731
00732 def get_allocator(self):
00733 """get_allocator(self) -> allocator_type"""
00734 return _SyFi.symexlist_get_allocator(self)
00735
00736 def begin(self):
00737 """begin(self) -> const_iterator"""
00738 return _SyFi.symexlist_begin(self)
00739
00740 def end(self):
00741 """end(self) -> const_iterator"""
00742 return _SyFi.symexlist_end(self)
00743
00744 def rbegin(self):
00745 """rbegin(self) -> const_reverse_iterator"""
00746 return _SyFi.symexlist_rbegin(self)
00747
00748 def rend(self):
00749 """rend(self) -> const_reverse_iterator"""
00750 return _SyFi.symexlist_rend(self)
00751
00752 def pop_back(self):
00753 """pop_back(self)"""
00754 return _SyFi.symexlist_pop_back(self)
00755
00756 def erase(self, *args):
00757 """
00758 erase(self, iterator pos) -> iterator
00759 erase(self, iterator first, iterator last) -> iterator
00760 """
00761 return _SyFi.symexlist_erase(self, *args)
00762
00763 def __init__(self, *args):
00764 """
00765 __init__(self) -> symexlist
00766 __init__(self, symexlist arg0) -> symexlist
00767 __init__(self, size_type size) -> symexlist
00768 __init__(self, size_type size, value_type value) -> symexlist
00769 """
00770 this = _SyFi.new_symexlist(*args)
00771 try: self.this.append(this)
00772 except: self.this = this
00773 def push_back(self, *args):
00774 """push_back(self, value_type x)"""
00775 return _SyFi.symexlist_push_back(self, *args)
00776
00777 def front(self):
00778 """front(self) -> value_type"""
00779 return _SyFi.symexlist_front(self)
00780
00781 def back(self):
00782 """back(self) -> value_type"""
00783 return _SyFi.symexlist_back(self)
00784
00785 def assign(self, *args):
00786 """assign(self, size_type n, value_type x)"""
00787 return _SyFi.symexlist_assign(self, *args)
00788
00789 def resize(self, *args):
00790 """
00791 resize(self, size_type new_size)
00792 resize(self, size_type new_size, value_type x)
00793 """
00794 return _SyFi.symexlist_resize(self, *args)
00795
00796 def insert(self, *args):
00797 """
00798 insert(self, iterator pos, value_type x) -> iterator
00799 insert(self, iterator pos, size_type n, value_type x)
00800 """
00801 return _SyFi.symexlist_insert(self, *args)
00802
00803 def pop_front(self):
00804 """pop_front(self)"""
00805 return _SyFi.symexlist_pop_front(self)
00806
00807 def push_front(self, *args):
00808 """push_front(self, value_type x)"""
00809 return _SyFi.symexlist_push_front(self, *args)
00810
00811 def reverse(self):
00812 """reverse(self)"""
00813 return _SyFi.symexlist_reverse(self)
00814
00815 __swig_destroy__ = _SyFi.delete_symexlist
00816 __del__ = lambda self : None;
00817 symexlist_swigregister = _SyFi.symexlist_swigregister
00818 symexlist_swigregister(symexlist)
00819
00820 class exlist(_object):
00821 """Proxy of C++ std::list<(GiNaC::ex)> class"""
00822 __swig_setmethods__ = {}
00823 __setattr__ = lambda self, name, value: _swig_setattr(self, exlist, name, value)
00824 __swig_getmethods__ = {}
00825 __getattr__ = lambda self, name: _swig_getattr(self, exlist, name)
00826 __repr__ = _swig_repr
00827 def iterator(self):
00828 """iterator(self) -> SwigPyIterator"""
00829 return _SyFi.exlist_iterator(self)
00830
00831 def __iter__(self): return self.iterator()
00832 def __nonzero__(self):
00833 """__nonzero__(self) -> bool"""
00834 return _SyFi.exlist___nonzero__(self)
00835
00836 def __bool__(self):
00837 """__bool__(self) -> bool"""
00838 return _SyFi.exlist___bool__(self)
00839
00840 def __len__(self):
00841 """__len__(self) -> size_type"""
00842 return _SyFi.exlist___len__(self)
00843
00844 def pop(self):
00845 """pop(self) -> value_type"""
00846 return _SyFi.exlist_pop(self)
00847
00848 def __getslice__(self, *args):
00849 """__getslice__(self, difference_type i, difference_type j) -> exlist"""
00850 return _SyFi.exlist___getslice__(self, *args)
00851
00852 def __setslice__(self, *args):
00853 """__setslice__(self, difference_type i, difference_type j, exlist v)"""
00854 return _SyFi.exlist___setslice__(self, *args)
00855
00856 def __delslice__(self, *args):
00857 """__delslice__(self, difference_type i, difference_type j)"""
00858 return _SyFi.exlist___delslice__(self, *args)
00859
00860 def __delitem__(self, *args):
00861 """
00862 __delitem__(self, difference_type i)
00863 __delitem__(self, PySliceObject slice)
00864 """
00865 return _SyFi.exlist___delitem__(self, *args)
00866
00867 def __getitem__(self, *args):
00868 """
00869 __getitem__(self, PySliceObject slice) -> exlist
00870 __getitem__(self, difference_type i) -> value_type
00871 """
00872 return _SyFi.exlist___getitem__(self, *args)
00873
00874 def __setitem__(self, *args):
00875 """
00876 __setitem__(self, PySliceObject slice, exlist v)
00877 __setitem__(self, difference_type i, value_type x)
00878 """
00879 return _SyFi.exlist___setitem__(self, *args)
00880
00881 def append(self, *args):
00882 """append(self, value_type x)"""
00883 return _SyFi.exlist_append(self, *args)
00884
00885 def empty(self):
00886 """empty(self) -> bool"""
00887 return _SyFi.exlist_empty(self)
00888
00889 def size(self):
00890 """size(self) -> size_type"""
00891 return _SyFi.exlist_size(self)
00892
00893 def clear(self):
00894 """clear(self)"""
00895 return _SyFi.exlist_clear(self)
00896
00897 def swap(self, *args):
00898 """swap(self, exlist v)"""
00899 return _SyFi.exlist_swap(self, *args)
00900
00901 def get_allocator(self):
00902 """get_allocator(self) -> allocator_type"""
00903 return _SyFi.exlist_get_allocator(self)
00904
00905 def begin(self):
00906 """begin(self) -> const_iterator"""
00907 return _SyFi.exlist_begin(self)
00908
00909 def end(self):
00910 """end(self) -> const_iterator"""
00911 return _SyFi.exlist_end(self)
00912
00913 def rbegin(self):
00914 """rbegin(self) -> const_reverse_iterator"""
00915 return _SyFi.exlist_rbegin(self)
00916
00917 def rend(self):
00918 """rend(self) -> const_reverse_iterator"""
00919 return _SyFi.exlist_rend(self)
00920
00921 def pop_back(self):
00922 """pop_back(self)"""
00923 return _SyFi.exlist_pop_back(self)
00924
00925 def erase(self, *args):
00926 """
00927 erase(self, iterator pos) -> iterator
00928 erase(self, iterator first, iterator last) -> iterator
00929 """
00930 return _SyFi.exlist_erase(self, *args)
00931
00932 def __init__(self, *args):
00933 """
00934 __init__(self) -> exlist
00935 __init__(self, exlist arg0) -> exlist
00936 __init__(self, size_type size) -> exlist
00937 __init__(self, size_type size, value_type value) -> exlist
00938 """
00939 this = _SyFi.new_exlist(*args)
00940 try: self.this.append(this)
00941 except: self.this = this
00942 def push_back(self, *args):
00943 """push_back(self, value_type x)"""
00944 return _SyFi.exlist_push_back(self, *args)
00945
00946 def front(self):
00947 """front(self) -> value_type"""
00948 return _SyFi.exlist_front(self)
00949
00950 def back(self):
00951 """back(self) -> value_type"""
00952 return _SyFi.exlist_back(self)
00953
00954 def assign(self, *args):
00955 """assign(self, size_type n, value_type x)"""
00956 return _SyFi.exlist_assign(self, *args)
00957
00958 def resize(self, *args):
00959 """
00960 resize(self, size_type new_size)
00961 resize(self, size_type new_size, value_type x)
00962 """
00963 return _SyFi.exlist_resize(self, *args)
00964
00965 def insert(self, *args):
00966 """
00967 insert(self, iterator pos, value_type x) -> iterator
00968 insert(self, iterator pos, size_type n, value_type x)
00969 """
00970 return _SyFi.exlist_insert(self, *args)
00971
00972 def pop_front(self):
00973 """pop_front(self)"""
00974 return _SyFi.exlist_pop_front(self)
00975
00976 def push_front(self, *args):
00977 """push_front(self, value_type x)"""
00978 return _SyFi.exlist_push_front(self, *args)
00979
00980 def reverse(self):
00981 """reverse(self)"""
00982 return _SyFi.exlist_reverse(self)
00983
00984 __swig_destroy__ = _SyFi.delete_exlist
00985 __del__ = lambda self : None;
00986 exlist_swigregister = _SyFi.exlist_swigregister
00987 exlist_swigregister(exlist)
00988
00989 class exset(_object):
00990 """Proxy of C++ std::set<(GiNaC::ex,GiNaC::ex_is_less)> class"""
00991 __swig_setmethods__ = {}
00992 __setattr__ = lambda self, name, value: _swig_setattr(self, exset, name, value)
00993 __swig_getmethods__ = {}
00994 __getattr__ = lambda self, name: _swig_getattr(self, exset, name)
00995 __repr__ = _swig_repr
00996 def iterator(self):
00997 """iterator(self) -> SwigPyIterator"""
00998 return _SyFi.exset_iterator(self)
00999
01000 def __iter__(self): return self.iterator()
01001 def __nonzero__(self):
01002 """__nonzero__(self) -> bool"""
01003 return _SyFi.exset___nonzero__(self)
01004
01005 def __bool__(self):
01006 """__bool__(self) -> bool"""
01007 return _SyFi.exset___bool__(self)
01008
01009 def __len__(self):
01010 """__len__(self) -> size_type"""
01011 return _SyFi.exset___len__(self)
01012
01013 def append(self, *args):
01014 """append(self, value_type x)"""
01015 return _SyFi.exset_append(self, *args)
01016
01017 def __contains__(self, *args):
01018 """__contains__(self, value_type x) -> bool"""
01019 return _SyFi.exset___contains__(self, *args)
01020
01021 def __getitem__(self, *args):
01022 """__getitem__(self, difference_type i) -> value_type"""
01023 return _SyFi.exset___getitem__(self, *args)
01024
01025 def __init__(self, *args):
01026 """
01027 __init__(self, GiNaC::ex_is_less arg0) -> exset
01028 __init__(self) -> exset
01029 __init__(self, exset arg0) -> exset
01030 """
01031 this = _SyFi.new_exset(*args)
01032 try: self.this.append(this)
01033 except: self.this = this
01034 def empty(self):
01035 """empty(self) -> bool"""
01036 return _SyFi.exset_empty(self)
01037
01038 def size(self):
01039 """size(self) -> size_type"""
01040 return _SyFi.exset_size(self)
01041
01042 def clear(self):
01043 """clear(self)"""
01044 return _SyFi.exset_clear(self)
01045
01046 def swap(self, *args):
01047 """swap(self, exset v)"""
01048 return _SyFi.exset_swap(self, *args)
01049
01050 def count(self, *args):
01051 """count(self, key_type x) -> size_type"""
01052 return _SyFi.exset_count(self, *args)
01053
01054 def begin(self):
01055 """begin(self) -> iterator"""
01056 return _SyFi.exset_begin(self)
01057
01058 def end(self):
01059 """end(self) -> iterator"""
01060 return _SyFi.exset_end(self)
01061
01062 def rbegin(self):
01063 """rbegin(self) -> reverse_iterator"""
01064 return _SyFi.exset_rbegin(self)
01065
01066 def rend(self):
01067 """rend(self) -> reverse_iterator"""
01068 return _SyFi.exset_rend(self)
01069
01070 def erase(self, *args):
01071 """
01072 erase(self, key_type x) -> size_type
01073 erase(self, iterator pos)
01074 erase(self, iterator first, iterator last)
01075 """
01076 return _SyFi.exset_erase(self, *args)
01077
01078 def find(self, *args):
01079 """find(self, key_type x) -> iterator"""
01080 return _SyFi.exset_find(self, *args)
01081
01082 def lower_bound(self, *args):
01083 """lower_bound(self, key_type x) -> iterator"""
01084 return _SyFi.exset_lower_bound(self, *args)
01085
01086 def upper_bound(self, *args):
01087 """upper_bound(self, key_type x) -> iterator"""
01088 return _SyFi.exset_upper_bound(self, *args)
01089
01090 def equal_range(self, *args):
01091 """equal_range(self, key_type x) -> std::pair<(std::set<(GiNaC::ex,GiNaC::ex_is_less)>::iterator,std::set<(GiNaC::ex,GiNaC::ex_is_less)>::iterator)>"""
01092 return _SyFi.exset_equal_range(self, *args)
01093
01094 def insert(self, *args):
01095 """insert(self, value_type __x) -> std::pair<(std::set<(GiNaC::ex,GiNaC::ex_is_less)>::iterator,bool)>"""
01096 return _SyFi.exset_insert(self, *args)
01097
01098 __swig_destroy__ = _SyFi.delete_exset
01099 __del__ = lambda self : None;
01100 exset_swigregister = _SyFi.exset_swigregister
01101 exset_swigregister(exset)
01102
01103 SYFILIB_MAJOR_VERSION = _SyFi.SYFILIB_MAJOR_VERSION
01104 SYFILIB_MINOR_VERSION = _SyFi.SYFILIB_MINOR_VERSION
01105 SYFILIB_MICRO_VERSION = _SyFi.SYFILIB_MICRO_VERSION
01106
01107 def dirac(*args):
01108 """dirac(unsigned int i, unsigned int j) -> int"""
01109 return _SyFi.dirac(*args)
01110
01111 def int2string(*args):
01112 """int2string(int i) -> string"""
01113 return _SyFi.int2string(*args)
01114
01115 def lst2string(*args):
01116 """lst2string(GiNaC::lst l) -> string"""
01117 return _SyFi.lst2string(*args)
01118
01119 def compare(*args):
01120 """compare(GiNaC::ex e, string s) -> bool"""
01121 return _SyFi.compare(*args)
01122
01123 def EQUAL_OR_DIE(*args):
01124 """EQUAL_OR_DIE(GiNaC::ex e, string s)"""
01125 return _SyFi.EQUAL_OR_DIE(*args)
01126
01127 def cross(*args):
01128 """cross(GiNaC::lst v1, GiNaC::lst v2) -> GiNaC::lst"""
01129 return _SyFi.cross(*args)
01130
01131 def ex2equations(*args):
01132 """ex2equations(GiNaC::ex rel) -> GiNaC::lst"""
01133 return _SyFi.ex2equations(*args)
01134
01135 def collapse(*args):
01136 """collapse(GiNaC::lst l) -> GiNaC::lst"""
01137 return _SyFi.collapse(*args)
01138
01139 def equations2matrix(*args):
01140 """equations2matrix(GiNaC::ex eqns, GiNaC::ex symbols) -> GiNaC::matrix"""
01141 return _SyFi.equations2matrix(*args)
01142
01143 def matrix_from_equations(*args):
01144 """
01145 matrix_from_equations(GiNaC::ex eqns, GiNaC::ex symbols, GiNaC::matrix A,
01146 GiNaC::matrix b)
01147 """
01148 return _SyFi.matrix_from_equations(*args)
01149
01150 def lst_to_matrix2(*args):
01151 """lst_to_matrix2(GiNaC::lst l) -> GiNaC::ex"""
01152 return _SyFi.lst_to_matrix2(*args)
01153
01154 def matrix_to_lst2(*args):
01155 """matrix_to_lst2(GiNaC::ex m) -> GiNaC::lst"""
01156 return _SyFi.matrix_to_lst2(*args)
01157
01158 def lst_equals(*args):
01159 """lst_equals(GiNaC::ex a, GiNaC::ex b) -> GiNaC::lst"""
01160 return _SyFi.lst_equals(*args)
01161
01162 def find(*args):
01163 """find(GiNaC::ex e, GiNaC::lst list) -> int"""
01164 return _SyFi.find(*args)
01165
01166 def check_visitor(*args):
01167 """check_visitor(GiNaC::ex e, GiNaC::lst exlist)"""
01168 return _SyFi.check_visitor(*args)
01169
01170 def visitor_subst_pow(*args):
01171 """visitor_subst_pow(GiNaC::ex e, GiNaC::exmap map, ex_int_map intmap, string a)"""
01172 return _SyFi.visitor_subst_pow(*args)
01173
01174 def pol(*args):
01175 """pol(unsigned int order, unsigned int nsd, string a) -> GiNaC::ex"""
01176 return _SyFi.pol(*args)
01177
01178 def polv(*args):
01179 """
01180 polv(unsigned int no_fields, unsigned int order, unsigned int nsd,
01181 string a) -> GiNaC::lst
01182 """
01183 return _SyFi.polv(*args)
01184
01185 def polb(*args):
01186 """polb(unsigned int order, unsigned int nsd, string a) -> GiNaC::ex"""
01187 return _SyFi.polb(*args)
01188
01189 def homogenous_pol(*args):
01190 """homogenous_pol(unsigned int order, unsigned int nsd, string a) -> GiNaC::ex"""
01191 return _SyFi.homogenous_pol(*args)
01192
01193 def homogenous_polv(*args):
01194 """
01195 homogenous_polv(unsigned int no_fields, unsigned int order, unsigned int nsd,
01196 string a) -> GiNaC::lst
01197 """
01198 return _SyFi.homogenous_polv(*args)
01199
01200 def legendre(*args):
01201 """legendre(unsigned int order, unsigned int nsd, string a) -> GiNaC::ex"""
01202 return _SyFi.legendre(*args)
01203
01204 def legendrev(*args):
01205 """
01206 legendrev(unsigned int no_fields, unsigned int order, unsigned int nsd,
01207 string a) -> GiNaC::lst
01208 """
01209 return _SyFi.legendrev(*args)
01210
01211 def coeff(*args):
01212 """coeff(GiNaC::ex pol) -> GiNaC::exvector"""
01213 return _SyFi.coeff(*args)
01214
01215 def count_symbols(*args):
01216 """count_symbols(GiNaC::ex e) -> GiNaC::exhashmap<(int)>"""
01217 return _SyFi.count_symbols(*args)
01218
01219 def extract_symbols(*args):
01220 """extract_symbols(GiNaC::ex e) -> GiNaC::ex"""
01221 return _SyFi.extract_symbols(*args)
01222 class ExStats(_object):
01223 """Proxy of C++ SyFi::ExStats class"""
01224 __swig_setmethods__ = {}
01225 __setattr__ = lambda self, name, value: _swig_setattr(self, ExStats, name, value)
01226 __swig_getmethods__ = {}
01227 __getattr__ = lambda self, name: _swig_getattr(self, ExStats, name)
01228 __repr__ = _swig_repr
01229 def __init__(self):
01230 """__init__(self) -> ExStats"""
01231 this = _SyFi.new_ExStats()
01232 try: self.this.append(this)
01233 except: self.this = this
01234 def __iadd__(self, *args):
01235 """__iadd__(self, ExStats rhs) -> ExStats"""
01236 return _SyFi.ExStats___iadd__(self, *args)
01237
01238 __swig_setmethods__["muls"] = _SyFi.ExStats_muls_set
01239 __swig_getmethods__["muls"] = _SyFi.ExStats_muls_get
01240 if _newclass:muls = _swig_property(_SyFi.ExStats_muls_get, _SyFi.ExStats_muls_set)
01241 __swig_setmethods__["adds"] = _SyFi.ExStats_adds_set
01242 __swig_getmethods__["adds"] = _SyFi.ExStats_adds_get
01243 if _newclass:adds = _swig_property(_SyFi.ExStats_adds_get, _SyFi.ExStats_adds_set)
01244 __swig_setmethods__["pows"] = _SyFi.ExStats_pows_set
01245 __swig_getmethods__["pows"] = _SyFi.ExStats_pows_get
01246 if _newclass:pows = _swig_property(_SyFi.ExStats_pows_get, _SyFi.ExStats_pows_set)
01247 __swig_setmethods__["functions"] = _SyFi.ExStats_functions_set
01248 __swig_getmethods__["functions"] = _SyFi.ExStats_functions_get
01249 if _newclass:functions = _swig_property(_SyFi.ExStats_functions_get, _SyFi.ExStats_functions_set)
01250 __swig_setmethods__["flops"] = _SyFi.ExStats_flops_set
01251 __swig_getmethods__["flops"] = _SyFi.ExStats_flops_get
01252 if _newclass:flops = _swig_property(_SyFi.ExStats_flops_get, _SyFi.ExStats_flops_set)
01253 __swig_destroy__ = _SyFi.delete_ExStats
01254 __del__ = lambda self : None;
01255 ExStats_swigregister = _SyFi.ExStats_swigregister
01256 ExStats_swigregister(ExStats)
01257 cvar = _SyFi.cvar
01258 version_major = cvar.version_major
01259 version_minor = cvar.version_minor
01260 version_micro = cvar.version_micro
01261
01262 def istr(*args):
01263 """
01264 istr(string a, int b) -> string
01265 istr(string a, int b, int c) -> string
01266 """
01267 return _SyFi.istr(*args)
01268
01269 def div(*args):
01270 """
01271 div(GiNaC::lst v) -> GiNaC::ex
01272 div(GiNaC::lst v, GiNaC::ex G) -> GiNaC::ex
01273 div(GiNaC::ex v) -> GiNaC::ex
01274 div(GiNaC::ex v, GiNaC::ex G) -> GiNaC::ex
01275 """
01276 return _SyFi.div(*args)
01277
01278 def grad(*args):
01279 """
01280 grad(GiNaC::ex f) -> GiNaC::ex
01281 grad(GiNaC::ex f, GiNaC::ex G) -> GiNaC::ex
01282 """
01283 return _SyFi.grad(*args)
01284
01285 def compare_archives(*args):
01286 """
01287 compare_archives(string first, string second, std::ostream os = std::cout) -> bool
01288 compare_archives(string first, string second) -> bool
01289 """
01290 return _SyFi.compare_archives(*args)
01291
01292 def inner(*args):
01293 """
01294 inner(GiNaC::ex a, GiNaC::ex b, bool transposed = False) -> GiNaC::ex
01295 inner(GiNaC::ex a, GiNaC::ex b) -> GiNaC::ex
01296 inner(GiNaC::exvector v1, GiNaC::exvector v2) -> GiNaC::ex
01297 inner(GiNaC::lst v1, GiNaC::lst v2) -> GiNaC::ex
01298 """
01299 return _SyFi.inner(*args)
01300
01301 def matvec(*args):
01302 """
01303 matvec(GiNaC::matrix M, GiNaC::lst x) -> GiNaC::lst
01304 matvec(GiNaC::ex A, GiNaC::ex x) -> GiNaC::ex
01305 """
01306 return _SyFi.matvec(*args)
01307
01308 def coeffs(*args):
01309 """
01310 coeffs(GiNaC::ex pol) -> GiNaC::lst
01311 coeffs(GiNaC::lst pols) -> GiNaC::lst
01312 """
01313 return _SyFi.coeffs(*args)
01314
01315 def pol2basisandcoeff(*args):
01316 """
01317 pol2basisandcoeff(GiNaC::ex e) -> GiNaC::exmap
01318 pol2basisandcoeff(GiNaC::ex e, GiNaC::ex s) -> GiNaC::exmap
01319 """
01320 return _SyFi.pol2basisandcoeff(*args)
01321
01322 def collect_symbols(*args):
01323 """
01324 collect_symbols(GiNaC::ex e, exset v)
01325 collect_symbols(GiNaC::ex e) -> GiNaC::exvector
01326 """
01327 return _SyFi.collect_symbols(*args)
01328
01329
01330 def count_ops(*args):
01331 """count_ops(GiNaC::ex e) -> ExStats"""
01332 return _SyFi.count_ops(*args)
01333
01334 def initSyFi(*args):
01335 """initSyFi(unsigned int nsd)"""
01336 return _SyFi.initSyFi(*args)
01337
01338 def symbol_exists(*args):
01339 """symbol_exists(string name) -> bool"""
01340 return _SyFi.symbol_exists(*args)
01341
01342 def get_symbol(*args):
01343 """get_symbol(string name) -> GiNaC::symbol"""
01344 return _SyFi.get_symbol(*args)
01345
01346 def get_symbolic_vector(*args):
01347 """get_symbolic_vector(int m, string basename) -> GiNaC::ex"""
01348 return _SyFi.get_symbolic_vector(*args)
01349
01350 def get_symbolic_matrix(*args):
01351 """get_symbolic_matrix(int m, int n, string basename) -> GiNaC::ex"""
01352 return _SyFi.get_symbolic_matrix(*args)
01353 SUBS_PERFORMED = _SyFi.SUBS_PERFORMED
01354 SUBS_NOT_PERFORMED = _SyFi.SUBS_NOT_PERFORMED
01355 class Polygon(_object):
01356 """Proxy of C++ SyFi::Polygon class"""
01357 __swig_setmethods__ = {}
01358 __setattr__ = lambda self, name, value: _swig_setattr(self, Polygon, name, value)
01359 __swig_getmethods__ = {}
01360 __getattr__ = lambda self, name: _swig_getattr(self, Polygon, name)
01361 def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
01362 __repr__ = _swig_repr
01363 __swig_destroy__ = _SyFi.delete_Polygon
01364 __del__ = lambda self : None;
01365 def no_space_dim(self):
01366 """no_space_dim(self) -> unsigned int"""
01367 return _SyFi.Polygon_no_space_dim(self)
01368
01369 def no_vertices(self):
01370 """no_vertices(self) -> unsigned int"""
01371 return _SyFi.Polygon_no_vertices(self)
01372
01373 def vertex(self, *args):
01374 """vertex(self, unsigned int i) -> GiNaC::ex"""
01375 return _SyFi.Polygon_vertex(self, *args)
01376
01377 def repr(self, *args):
01378 """
01379 repr(self, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01380 repr(self) -> GiNaC::ex
01381 """
01382 return _SyFi.Polygon_repr(self, *args)
01383
01384 def str(self):
01385 """str(self) -> string"""
01386 return _SyFi.Polygon_str(self)
01387
01388 def integrate(self, *args):
01389 """
01390 integrate(self, GiNaC::ex f, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01391 integrate(self, GiNaC::ex f) -> GiNaC::ex
01392 """
01393 return _SyFi.Polygon_integrate(self, *args)
01394
01395 def copy(self):
01396 """copy(self) -> Polygon"""
01397 return _SyFi.Polygon_copy(self)
01398
01399 def line(self, *args):
01400 """line(self, unsigned int i) -> Line"""
01401 return _SyFi.Polygon_line(self, *args)
01402
01403 def triangle(self, *args):
01404 """triangle(self, unsigned int i) -> Triangle"""
01405 return _SyFi.Polygon_triangle(self, *args)
01406
01407 def rectangle(self, *args):
01408 """rectangle(self, unsigned int i) -> Rectangle"""
01409 return _SyFi.Polygon_rectangle(self, *args)
01410
01411 Polygon_swigregister = _SyFi.Polygon_swigregister
01412 Polygon_swigregister(Polygon)
01413
01414 def replace_powers(*args):
01415 """
01416 replace_powers(GiNaC::ex e, std::list<(GiNaC::symbol,std::allocator<(GiNaC::symbol)>)> symbols,
01417 std::list<(SyFi::symexpair,std::allocator<(SyFi::symexpair)>)> sel,
01418 string tmpsymbolprefix = "p_") -> GiNaC::ex
01419 replace_powers(GiNaC::ex e, std::list<(GiNaC::symbol,std::allocator<(GiNaC::symbol)>)> symbols,
01420 std::list<(SyFi::symexpair,std::allocator<(SyFi::symexpair)>)> sel) -> GiNaC::ex
01421 """
01422 return _SyFi.replace_powers(*args)
01423
01424 def isymb(*args):
01425 """
01426 isymb(string a, int b) -> GiNaC::symbol
01427 isymb(string a, int b, int c) -> GiNaC::symbol
01428 """
01429 return _SyFi.isymb(*args)
01430
01431 class Line(Polygon):
01432 """Proxy of C++ SyFi::Line class"""
01433 __swig_setmethods__ = {}
01434 for _s in [Polygon]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
01435 __setattr__ = lambda self, name, value: _swig_setattr(self, Line, name, value)
01436 __swig_getmethods__ = {}
01437 for _s in [Polygon]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
01438 __getattr__ = lambda self, name: _swig_getattr(self, Line, name)
01439 __repr__ = _swig_repr
01440 def __init__(self, *args):
01441 """
01442 __init__(self) -> Line
01443 __init__(self, GiNaC::ex x0, GiNaC::ex x1, string subscript = "") -> Line
01444 __init__(self, GiNaC::ex x0, GiNaC::ex x1) -> Line
01445 __init__(self, Line line) -> Line
01446 """
01447 this = _SyFi.new_Line(*args)
01448 try: self.this.append(this)
01449 except: self.this = this
01450 __swig_destroy__ = _SyFi.delete_Line
01451 __del__ = lambda self : None;
01452 def no_space_dim(self):
01453 """no_space_dim(self) -> unsigned int"""
01454 return _SyFi.Line_no_space_dim(self)
01455
01456 def a(self):
01457 """a(self) -> GiNaC::ex"""
01458 return _SyFi.Line_a(self)
01459
01460 def b(self):
01461 """b(self) -> GiNaC::ex"""
01462 return _SyFi.Line_b(self)
01463
01464 def repr(self, *args):
01465 """
01466 repr(self, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01467 repr(self) -> GiNaC::ex
01468 repr(self, GiNaC::ex t, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01469 repr(self, GiNaC::ex t) -> GiNaC::ex
01470 """
01471 return _SyFi.Line_repr(self, *args)
01472
01473 def str(self):
01474 """str(self) -> string"""
01475 return _SyFi.Line_str(self)
01476
01477 def integrate(self, *args):
01478 """
01479 integrate(self, GiNaC::ex f, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01480 integrate(self, GiNaC::ex f) -> GiNaC::ex
01481 """
01482 return _SyFi.Line_integrate(self, *args)
01483
01484 def copy(self):
01485 """copy(self) -> Line"""
01486 return _SyFi.Line_copy(self)
01487
01488 Line_swigregister = _SyFi.Line_swigregister
01489 Line_swigregister(Line)
01490
01491 class ReferenceLine(Line):
01492 """Proxy of C++ SyFi::ReferenceLine class"""
01493 __swig_setmethods__ = {}
01494 for _s in [Line]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
01495 __setattr__ = lambda self, name, value: _swig_setattr(self, ReferenceLine, name, value)
01496 __swig_getmethods__ = {}
01497 for _s in [Line]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
01498 __getattr__ = lambda self, name: _swig_getattr(self, ReferenceLine, name)
01499 __repr__ = _swig_repr
01500 def __init__(self, *args):
01501 """
01502 __init__(self, string subscript = "") -> ReferenceLine
01503 __init__(self) -> ReferenceLine
01504 __init__(self, ReferenceLine line) -> ReferenceLine
01505 """
01506 this = _SyFi.new_ReferenceLine(*args)
01507 try: self.this.append(this)
01508 except: self.this = this
01509 __swig_destroy__ = _SyFi.delete_ReferenceLine
01510 __del__ = lambda self : None;
01511 def repr(self, *args):
01512 """
01513 repr(self, GiNaC::ex t, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01514 repr(self, GiNaC::ex t) -> GiNaC::ex
01515 """
01516 return _SyFi.ReferenceLine_repr(self, *args)
01517
01518 def str(self):
01519 """str(self) -> string"""
01520 return _SyFi.ReferenceLine_str(self)
01521
01522 def integrate(self, *args):
01523 """
01524 integrate(self, GiNaC::ex f, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01525 integrate(self, GiNaC::ex f) -> GiNaC::ex
01526 """
01527 return _SyFi.ReferenceLine_integrate(self, *args)
01528
01529 def copy(self):
01530 """copy(self) -> ReferenceLine"""
01531 return _SyFi.ReferenceLine_copy(self)
01532
01533 ReferenceLine_swigregister = _SyFi.ReferenceLine_swigregister
01534 ReferenceLine_swigregister(ReferenceLine)
01535
01536 class Triangle(Polygon):
01537 """Proxy of C++ SyFi::Triangle class"""
01538 __swig_setmethods__ = {}
01539 for _s in [Polygon]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
01540 __setattr__ = lambda self, name, value: _swig_setattr(self, Triangle, name, value)
01541 __swig_getmethods__ = {}
01542 for _s in [Polygon]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
01543 __getattr__ = lambda self, name: _swig_getattr(self, Triangle, name)
01544 __repr__ = _swig_repr
01545 def __init__(self, *args):
01546 """
01547 __init__(self, GiNaC::ex x0, GiNaC::ex x1, GiNaC::ex x2, string subscript = "") -> Triangle
01548 __init__(self, GiNaC::ex x0, GiNaC::ex x1, GiNaC::ex x2) -> Triangle
01549 __init__(self, Triangle triangle) -> Triangle
01550 """
01551 this = _SyFi.new_Triangle(*args)
01552 try: self.this.append(this)
01553 except: self.this = this
01554 __swig_destroy__ = _SyFi.delete_Triangle
01555 __del__ = lambda self : None;
01556 def no_space_dim(self):
01557 """no_space_dim(self) -> unsigned int"""
01558 return _SyFi.Triangle_no_space_dim(self)
01559
01560 def line(self, *args):
01561 """line(self, unsigned int i) -> Line"""
01562 return _SyFi.Triangle_line(self, *args)
01563
01564 def repr(self, *args):
01565 """
01566 repr(self, Repr_format arg0 = SUBS_PERFORMED) -> GiNaC::ex
01567 repr(self) -> GiNaC::ex
01568 """
01569 return _SyFi.Triangle_repr(self, *args)
01570
01571 def str(self):
01572 """str(self) -> string"""
01573 return _SyFi.Triangle_str(self)
01574
01575 def integrate(self, *args):
01576 """
01577 integrate(self, GiNaC::ex f, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01578 integrate(self, GiNaC::ex f) -> GiNaC::ex
01579 """
01580 return _SyFi.Triangle_integrate(self, *args)
01581
01582 def copy(self):
01583 """copy(self) -> Triangle"""
01584 return _SyFi.Triangle_copy(self)
01585
01586 Triangle_swigregister = _SyFi.Triangle_swigregister
01587 Triangle_swigregister(Triangle)
01588
01589 class ReferenceTriangle(Triangle):
01590 """Proxy of C++ SyFi::ReferenceTriangle class"""
01591 __swig_setmethods__ = {}
01592 for _s in [Triangle]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
01593 __setattr__ = lambda self, name, value: _swig_setattr(self, ReferenceTriangle, name, value)
01594 __swig_getmethods__ = {}
01595 for _s in [Triangle]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
01596 __getattr__ = lambda self, name: _swig_getattr(self, ReferenceTriangle, name)
01597 __repr__ = _swig_repr
01598 def __init__(self, *args):
01599 """
01600 __init__(self, string subscript = "") -> ReferenceTriangle
01601 __init__(self) -> ReferenceTriangle
01602 __init__(self, ReferenceTriangle triangle) -> ReferenceTriangle
01603 """
01604 this = _SyFi.new_ReferenceTriangle(*args)
01605 try: self.this.append(this)
01606 except: self.this = this
01607 __swig_destroy__ = _SyFi.delete_ReferenceTriangle
01608 __del__ = lambda self : None;
01609 def str(self):
01610 """str(self) -> string"""
01611 return _SyFi.ReferenceTriangle_str(self)
01612
01613 def integrate(self, *args):
01614 """
01615 integrate(self, GiNaC::ex f, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01616 integrate(self, GiNaC::ex f) -> GiNaC::ex
01617 """
01618 return _SyFi.ReferenceTriangle_integrate(self, *args)
01619
01620 def copy(self):
01621 """copy(self) -> ReferenceTriangle"""
01622 return _SyFi.ReferenceTriangle_copy(self)
01623
01624 ReferenceTriangle_swigregister = _SyFi.ReferenceTriangle_swigregister
01625 ReferenceTriangle_swigregister(ReferenceTriangle)
01626
01627 class Rectangle(Polygon):
01628 """Proxy of C++ SyFi::Rectangle class"""
01629 __swig_setmethods__ = {}
01630 for _s in [Polygon]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
01631 __setattr__ = lambda self, name, value: _swig_setattr(self, Rectangle, name, value)
01632 __swig_getmethods__ = {}
01633 for _s in [Polygon]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
01634 __getattr__ = lambda self, name: _swig_getattr(self, Rectangle, name)
01635 __repr__ = _swig_repr
01636 def __init__(self, *args):
01637 """
01638 __init__(self, GiNaC::ex p0, GiNaC::ex p1, string subscript = "") -> Rectangle
01639 __init__(self, GiNaC::ex p0, GiNaC::ex p1) -> Rectangle
01640 __init__(self, GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2, GiNaC::ex p3,
01641 string subscript = "") -> Rectangle
01642 __init__(self, GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2, GiNaC::ex p3) -> Rectangle
01643 __init__(self, Rectangle rectangle) -> Rectangle
01644 """
01645 this = _SyFi.new_Rectangle(*args)
01646 try: self.this.append(this)
01647 except: self.this = this
01648 __swig_destroy__ = _SyFi.delete_Rectangle
01649 __del__ = lambda self : None;
01650 def no_space_dim(self):
01651 """no_space_dim(self) -> unsigned int"""
01652 return _SyFi.Rectangle_no_space_dim(self)
01653
01654 def line(self, *args):
01655 """line(self, unsigned int i) -> Line"""
01656 return _SyFi.Rectangle_line(self, *args)
01657
01658 def repr(self, *args):
01659 """
01660 repr(self, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01661 repr(self) -> GiNaC::ex
01662 """
01663 return _SyFi.Rectangle_repr(self, *args)
01664
01665 def str(self):
01666 """str(self) -> string"""
01667 return _SyFi.Rectangle_str(self)
01668
01669 def integrate(self, *args):
01670 """
01671 integrate(self, GiNaC::ex f, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01672 integrate(self, GiNaC::ex f) -> GiNaC::ex
01673 """
01674 return _SyFi.Rectangle_integrate(self, *args)
01675
01676 def copy(self):
01677 """copy(self) -> Rectangle"""
01678 return _SyFi.Rectangle_copy(self)
01679
01680 Rectangle_swigregister = _SyFi.Rectangle_swigregister
01681 Rectangle_swigregister(Rectangle)
01682
01683 class ReferenceRectangle(Rectangle):
01684 """Proxy of C++ SyFi::ReferenceRectangle class"""
01685 __swig_setmethods__ = {}
01686 for _s in [Rectangle]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
01687 __setattr__ = lambda self, name, value: _swig_setattr(self, ReferenceRectangle, name, value)
01688 __swig_getmethods__ = {}
01689 for _s in [Rectangle]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
01690 __getattr__ = lambda self, name: _swig_getattr(self, ReferenceRectangle, name)
01691 __repr__ = _swig_repr
01692 def __init__(self, *args):
01693 """
01694 __init__(self, string subscript = "") -> ReferenceRectangle
01695 __init__(self) -> ReferenceRectangle
01696 __init__(self, ReferenceRectangle rectangle) -> ReferenceRectangle
01697 """
01698 this = _SyFi.new_ReferenceRectangle(*args)
01699 try: self.this.append(this)
01700 except: self.this = this
01701 __swig_destroy__ = _SyFi.delete_ReferenceRectangle
01702 __del__ = lambda self : None;
01703 def str(self):
01704 """str(self) -> string"""
01705 return _SyFi.ReferenceRectangle_str(self)
01706
01707 def copy(self):
01708 """copy(self) -> ReferenceRectangle"""
01709 return _SyFi.ReferenceRectangle_copy(self)
01710
01711 ReferenceRectangle_swigregister = _SyFi.ReferenceRectangle_swigregister
01712 ReferenceRectangle_swigregister(ReferenceRectangle)
01713
01714 class Tetrahedron(Polygon):
01715 """Proxy of C++ SyFi::Tetrahedron class"""
01716 __swig_setmethods__ = {}
01717 for _s in [Polygon]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
01718 __setattr__ = lambda self, name, value: _swig_setattr(self, Tetrahedron, name, value)
01719 __swig_getmethods__ = {}
01720 for _s in [Polygon]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
01721 __getattr__ = lambda self, name: _swig_getattr(self, Tetrahedron, name)
01722 __repr__ = _swig_repr
01723 def __init__(self, *args):
01724 """
01725 __init__(self, GiNaC::ex x0, GiNaC::ex x1, GiNaC::ex x2, GiNaC::ex x3,
01726 string subscript = "") -> Tetrahedron
01727 __init__(self, GiNaC::ex x0, GiNaC::ex x1, GiNaC::ex x2, GiNaC::ex x3) -> Tetrahedron
01728 __init__(self, Tetrahedron tetrahedron) -> Tetrahedron
01729 """
01730 this = _SyFi.new_Tetrahedron(*args)
01731 try: self.this.append(this)
01732 except: self.this = this
01733 __swig_destroy__ = _SyFi.delete_Tetrahedron
01734 __del__ = lambda self : None;
01735 def no_space_dim(self):
01736 """no_space_dim(self) -> unsigned int"""
01737 return _SyFi.Tetrahedron_no_space_dim(self)
01738
01739 def line(self, *args):
01740 """line(self, unsigned int i) -> Line"""
01741 return _SyFi.Tetrahedron_line(self, *args)
01742
01743 def triangle(self, *args):
01744 """triangle(self, unsigned int i) -> Triangle"""
01745 return _SyFi.Tetrahedron_triangle(self, *args)
01746
01747 def repr(self, *args):
01748 """
01749 repr(self, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01750 repr(self) -> GiNaC::ex
01751 """
01752 return _SyFi.Tetrahedron_repr(self, *args)
01753
01754 def str(self):
01755 """str(self) -> string"""
01756 return _SyFi.Tetrahedron_str(self)
01757
01758 def integrate(self, *args):
01759 """
01760 integrate(self, GiNaC::ex f, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01761 integrate(self, GiNaC::ex f) -> GiNaC::ex
01762 """
01763 return _SyFi.Tetrahedron_integrate(self, *args)
01764
01765 def copy(self):
01766 """copy(self) -> Tetrahedron"""
01767 return _SyFi.Tetrahedron_copy(self)
01768
01769 Tetrahedron_swigregister = _SyFi.Tetrahedron_swigregister
01770 Tetrahedron_swigregister(Tetrahedron)
01771
01772 class ReferenceTetrahedron(Tetrahedron):
01773 """Proxy of C++ SyFi::ReferenceTetrahedron class"""
01774 __swig_setmethods__ = {}
01775 for _s in [Tetrahedron]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
01776 __setattr__ = lambda self, name, value: _swig_setattr(self, ReferenceTetrahedron, name, value)
01777 __swig_getmethods__ = {}
01778 for _s in [Tetrahedron]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
01779 __getattr__ = lambda self, name: _swig_getattr(self, ReferenceTetrahedron, name)
01780 __repr__ = _swig_repr
01781 def __init__(self, *args):
01782 """
01783 __init__(self, string subscript = "") -> ReferenceTetrahedron
01784 __init__(self) -> ReferenceTetrahedron
01785 __init__(self, ReferenceTetrahedron tetrahedron) -> ReferenceTetrahedron
01786 """
01787 this = _SyFi.new_ReferenceTetrahedron(*args)
01788 try: self.this.append(this)
01789 except: self.this = this
01790 __swig_destroy__ = _SyFi.delete_ReferenceTetrahedron
01791 __del__ = lambda self : None;
01792 def str(self):
01793 """str(self) -> string"""
01794 return _SyFi.ReferenceTetrahedron_str(self)
01795
01796 def integrate(self, *args):
01797 """
01798 integrate(self, GiNaC::ex f, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01799 integrate(self, GiNaC::ex f) -> GiNaC::ex
01800 """
01801 return _SyFi.ReferenceTetrahedron_integrate(self, *args)
01802
01803 def copy(self):
01804 """copy(self) -> ReferenceTetrahedron"""
01805 return _SyFi.ReferenceTetrahedron_copy(self)
01806
01807 ReferenceTetrahedron_swigregister = _SyFi.ReferenceTetrahedron_swigregister
01808 ReferenceTetrahedron_swigregister(ReferenceTetrahedron)
01809
01810 class Box(Polygon):
01811 """Proxy of C++ SyFi::Box class"""
01812 __swig_setmethods__ = {}
01813 for _s in [Polygon]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
01814 __setattr__ = lambda self, name, value: _swig_setattr(self, Box, name, value)
01815 __swig_getmethods__ = {}
01816 for _s in [Polygon]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
01817 __getattr__ = lambda self, name: _swig_getattr(self, Box, name)
01818 __repr__ = _swig_repr
01819 def __init__(self, *args):
01820 """
01821 __init__(self, GiNaC::ex p0, GiNaC::ex p1, string subscript = "") -> Box
01822 __init__(self, GiNaC::ex p0, GiNaC::ex p1) -> Box
01823 __init__(self, GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2, GiNaC::ex p3,
01824 GiNaC::ex p4, GiNaC::ex p5, GiNaC::ex p6,
01825 GiNaC::ex p7, string subscript = "") -> Box
01826 __init__(self, GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2, GiNaC::ex p3,
01827 GiNaC::ex p4, GiNaC::ex p5, GiNaC::ex p6,
01828 GiNaC::ex p7) -> Box
01829 __init__(self, Box box) -> Box
01830 __init__(self) -> Box
01831 """
01832 this = _SyFi.new_Box(*args)
01833 try: self.this.append(this)
01834 except: self.this = this
01835 __swig_destroy__ = _SyFi.delete_Box
01836 __del__ = lambda self : None;
01837 def no_space_dim(self):
01838 """no_space_dim(self) -> unsigned int"""
01839 return _SyFi.Box_no_space_dim(self)
01840
01841 def line(self, *args):
01842 """line(self, unsigned int i) -> Line"""
01843 return _SyFi.Box_line(self, *args)
01844
01845 def rectangle(self, *args):
01846 """rectangle(self, unsigned int i) -> Rectangle"""
01847 return _SyFi.Box_rectangle(self, *args)
01848
01849 def repr(self, *args):
01850 """
01851 repr(self, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01852 repr(self) -> GiNaC::ex
01853 """
01854 return _SyFi.Box_repr(self, *args)
01855
01856 def str(self):
01857 """str(self) -> string"""
01858 return _SyFi.Box_str(self)
01859
01860 def integrate(self, *args):
01861 """
01862 integrate(self, GiNaC::ex f, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01863 integrate(self, GiNaC::ex f) -> GiNaC::ex
01864 """
01865 return _SyFi.Box_integrate(self, *args)
01866
01867 def copy(self):
01868 """copy(self) -> Box"""
01869 return _SyFi.Box_copy(self)
01870
01871 Box_swigregister = _SyFi.Box_swigregister
01872 Box_swigregister(Box)
01873
01874 class ReferenceBox(Box):
01875 """Proxy of C++ SyFi::ReferenceBox class"""
01876 __swig_setmethods__ = {}
01877 for _s in [Box]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
01878 __setattr__ = lambda self, name, value: _swig_setattr(self, ReferenceBox, name, value)
01879 __swig_getmethods__ = {}
01880 for _s in [Box]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
01881 __getattr__ = lambda self, name: _swig_getattr(self, ReferenceBox, name)
01882 __repr__ = _swig_repr
01883 def __init__(self, *args):
01884 """
01885 __init__(self, string subscript = "") -> ReferenceBox
01886 __init__(self) -> ReferenceBox
01887 __init__(self, ReferenceBox box) -> ReferenceBox
01888 """
01889 this = _SyFi.new_ReferenceBox(*args)
01890 try: self.this.append(this)
01891 except: self.this = this
01892 __swig_destroy__ = _SyFi.delete_ReferenceBox
01893 __del__ = lambda self : None;
01894 def str(self):
01895 """str(self) -> string"""
01896 return _SyFi.ReferenceBox_str(self)
01897
01898 def copy(self):
01899 """copy(self) -> ReferenceBox"""
01900 return _SyFi.ReferenceBox_copy(self)
01901
01902 ReferenceBox_swigregister = _SyFi.ReferenceBox_swigregister
01903 ReferenceBox_swigregister(ReferenceBox)
01904
01905 class Simplex(Polygon):
01906 """Proxy of C++ SyFi::Simplex class"""
01907 __swig_setmethods__ = {}
01908 for _s in [Polygon]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
01909 __setattr__ = lambda self, name, value: _swig_setattr(self, Simplex, name, value)
01910 __swig_getmethods__ = {}
01911 for _s in [Polygon]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
01912 __getattr__ = lambda self, name: _swig_getattr(self, Simplex, name)
01913 __repr__ = _swig_repr
01914 def __init__(self, *args):
01915 """
01916 __init__(self, GiNaC::lst vertices, string subscript = "") -> Simplex
01917 __init__(self, GiNaC::lst vertices) -> Simplex
01918 __init__(self, Simplex simplex) -> Simplex
01919 """
01920 this = _SyFi.new_Simplex(*args)
01921 try: self.this.append(this)
01922 except: self.this = this
01923 __swig_destroy__ = _SyFi.delete_Simplex
01924 __del__ = lambda self : None;
01925 def no_space_dim(self):
01926 """no_space_dim(self) -> unsigned int"""
01927 return _SyFi.Simplex_no_space_dim(self)
01928
01929 def repr(self, *args):
01930 """
01931 repr(self, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01932 repr(self) -> GiNaC::ex
01933 """
01934 return _SyFi.Simplex_repr(self, *args)
01935
01936 def str(self):
01937 """str(self) -> string"""
01938 return _SyFi.Simplex_str(self)
01939
01940 def integrate(self, *args):
01941 """
01942 integrate(self, GiNaC::ex f, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
01943 integrate(self, GiNaC::ex f) -> GiNaC::ex
01944 """
01945 return _SyFi.Simplex_integrate(self, *args)
01946
01947 def sub_simplex(self, *args):
01948 """sub_simplex(self, unsigned int i) -> Simplex"""
01949 return _SyFi.Simplex_sub_simplex(self, *args)
01950
01951 def copy(self):
01952 """copy(self) -> Simplex"""
01953 return _SyFi.Simplex_copy(self)
01954
01955 Simplex_swigregister = _SyFi.Simplex_swigregister
01956 Simplex_swigregister(Simplex)
01957
01958
01959 def barycenter_line(*args):
01960 """barycenter_line(GiNaC::ex p0, GiNaC::ex p1) -> GiNaC::ex"""
01961 return _SyFi.barycenter_line(*args)
01962
01963 def barycenter_triangle(*args):
01964 """barycenter_triangle(GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2) -> GiNaC::ex"""
01965 return _SyFi.barycenter_triangle(*args)
01966
01967 def barycenter_tetrahedron(*args):
01968 """barycenter_tetrahedron(GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2, GiNaC::ex p3) -> GiNaC::ex"""
01969 return _SyFi.barycenter_tetrahedron(*args)
01970
01971 def barycenter(*args):
01972 """barycenter(Simplex simplex) -> GiNaC::ex"""
01973 return _SyFi.barycenter(*args)
01974
01975 def bernstein(*args):
01976 """bernstein(unsigned int order, Polygon p, string a) -> GiNaC::ex"""
01977 return _SyFi.bernstein(*args)
01978
01979 def bernsteinv(*args):
01980 """
01981 bernsteinv(unsigned int no_fields, unsigned int order, Polygon p,
01982 string a) -> GiNaC::lst
01983 """
01984 return _SyFi.bernsteinv(*args)
01985
01986 def tangent(*args):
01987 """tangent(Triangle arg0, unsigned int i) -> GiNaC::lst"""
01988 return _SyFi.tangent(*args)
01989 class FE(_object):
01990 """Proxy of C++ SyFi::FE class"""
01991 __swig_setmethods__ = {}
01992 __setattr__ = lambda self, name, value: _swig_setattr(self, FE, name, value)
01993 __swig_getmethods__ = {}
01994 __getattr__ = lambda self, name: _swig_getattr(self, FE, name)
01995 def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
01996 __repr__ = _swig_repr
01997 __swig_destroy__ = _SyFi.delete_FE
01998 __del__ = lambda self : None;
01999 def set_polygon(self, *args):
02000 """set_polygon(self, Polygon p)"""
02001 return _SyFi.FE_set_polygon(self, *args)
02002
02003 def get_polygon(self):
02004 """get_polygon(self) -> Polygon"""
02005 return _SyFi.FE_get_polygon(self)
02006
02007 def compute_basis_functions(self):
02008 """compute_basis_functions(self)"""
02009 return _SyFi.FE_compute_basis_functions(self)
02010
02011 def nbf(self):
02012 """nbf(self) -> unsigned int"""
02013 return _SyFi.FE_nbf(self)
02014
02015 def N(self, *args):
02016 """N(self, unsigned int i) -> GiNaC::ex"""
02017 return _SyFi.FE_N(self, *args)
02018
02019 def dof(self, *args):
02020 """dof(self, unsigned int i) -> GiNaC::ex"""
02021 return _SyFi.FE_dof(self, *args)
02022
02023 def str(self):
02024 """str(self) -> string"""
02025 return _SyFi.FE_str(self)
02026
02027 FE_swigregister = _SyFi.FE_swigregister
02028 FE_swigregister(FE)
02029
02030 def bezier_ordinates(*args):
02031 """
02032 bezier_ordinates(Line line, unsigned int d) -> GiNaC::lst
02033 bezier_ordinates(Triangle triangle, unsigned int d) -> GiNaC::lst
02034 bezier_ordinates(Tetrahedron tetrahedra, unsigned int d) -> GiNaC::lst
02035 """
02036 return _SyFi.bezier_ordinates(*args)
02037
02038 def interior_coordinates(*args):
02039 """
02040 interior_coordinates(Line line, unsigned int d) -> GiNaC::lst
02041 interior_coordinates(Triangle triangle, unsigned int d) -> GiNaC::lst
02042 interior_coordinates(Tetrahedron tetrahedra, unsigned int d) -> GiNaC::lst
02043 """
02044 return _SyFi.interior_coordinates(*args)
02045
02046 def normal(*args):
02047 """
02048 normal(Triangle arg0, unsigned int i) -> GiNaC::lst
02049 normal(Tetrahedron arg0, unsigned int i) -> GiNaC::lst
02050 """
02051 return _SyFi.normal(*args)
02052
02053 class StandardFE(FE):
02054 """Proxy of C++ SyFi::StandardFE class"""
02055 __swig_setmethods__ = {}
02056 for _s in [FE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02057 __setattr__ = lambda self, name, value: _swig_setattr(self, StandardFE, name, value)
02058 __swig_getmethods__ = {}
02059 for _s in [FE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02060 __getattr__ = lambda self, name: _swig_getattr(self, StandardFE, name)
02061 __repr__ = _swig_repr
02062 def __init__(self, *args):
02063 """
02064 __init__(self) -> StandardFE
02065 __init__(self, Polygon p, unsigned int order) -> StandardFE
02066 """
02067 this = _SyFi.new_StandardFE(*args)
02068 try: self.this.append(this)
02069 except: self.this = this
02070 __swig_destroy__ = _SyFi.delete_StandardFE
02071 __del__ = lambda self : None;
02072 def set_order(self, *args):
02073 """set_order(self, unsigned int order)"""
02074 return _SyFi.StandardFE_set_order(self, *args)
02075
02076 def get_order(self):
02077 """get_order(self) -> unsigned int"""
02078 return _SyFi.StandardFE_get_order(self)
02079
02080 def set_polygon(self, *args):
02081 """set_polygon(self, Polygon p)"""
02082 return _SyFi.StandardFE_set_polygon(self, *args)
02083
02084 def get_polygon(self):
02085 """get_polygon(self) -> Polygon"""
02086 return _SyFi.StandardFE_get_polygon(self)
02087
02088 def compute_basis_functions(self):
02089 """compute_basis_functions(self)"""
02090 return _SyFi.StandardFE_compute_basis_functions(self)
02091
02092 def nbf(self):
02093 """nbf(self) -> unsigned int"""
02094 return _SyFi.StandardFE_nbf(self)
02095
02096 def N(self, *args):
02097 """N(self, unsigned int i) -> GiNaC::ex"""
02098 return _SyFi.StandardFE_N(self, *args)
02099
02100 def dof(self, *args):
02101 """dof(self, unsigned int i) -> GiNaC::ex"""
02102 return _SyFi.StandardFE_dof(self, *args)
02103
02104 def str(self):
02105 """str(self) -> string"""
02106 return _SyFi.StandardFE_str(self)
02107
02108 StandardFE_swigregister = _SyFi.StandardFE_swigregister
02109 StandardFE_swigregister(StandardFE)
02110
02111 class Lagrange(StandardFE):
02112 """Proxy of C++ SyFi::Lagrange class"""
02113 __swig_setmethods__ = {}
02114 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02115 __setattr__ = lambda self, name, value: _swig_setattr(self, Lagrange, name, value)
02116 __swig_getmethods__ = {}
02117 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02118 __getattr__ = lambda self, name: _swig_getattr(self, Lagrange, name)
02119 __repr__ = _swig_repr
02120 def __init__(self, *args):
02121 """
02122 __init__(self) -> Lagrange
02123 __init__(self, Polygon p, unsigned int order = 1) -> Lagrange
02124 __init__(self, Polygon p) -> Lagrange
02125 """
02126 this = _SyFi.new_Lagrange(*args)
02127 try: self.this.append(this)
02128 except: self.this = this
02129 __swig_destroy__ = _SyFi.delete_Lagrange
02130 __del__ = lambda self : None;
02131 def compute_basis_functions(self):
02132 """compute_basis_functions(self)"""
02133 return _SyFi.Lagrange_compute_basis_functions(self)
02134
02135 Lagrange_swigregister = _SyFi.Lagrange_swigregister
02136 Lagrange_swigregister(Lagrange)
02137
02138 class VectorLagrange(StandardFE):
02139 """Proxy of C++ SyFi::VectorLagrange class"""
02140 __swig_setmethods__ = {}
02141 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02142 __setattr__ = lambda self, name, value: _swig_setattr(self, VectorLagrange, name, value)
02143 __swig_getmethods__ = {}
02144 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02145 __getattr__ = lambda self, name: _swig_getattr(self, VectorLagrange, name)
02146 __repr__ = _swig_repr
02147 def __init__(self, *args):
02148 """
02149 __init__(self) -> VectorLagrange
02150 __init__(self, Polygon p, unsigned int order = 1, unsigned int size = 0) -> VectorLagrange
02151 __init__(self, Polygon p, unsigned int order = 1) -> VectorLagrange
02152 __init__(self, Polygon p) -> VectorLagrange
02153 """
02154 this = _SyFi.new_VectorLagrange(*args)
02155 try: self.this.append(this)
02156 except: self.this = this
02157 __swig_destroy__ = _SyFi.delete_VectorLagrange
02158 __del__ = lambda self : None;
02159 def set_size(self, *args):
02160 """set_size(self, unsigned int size_)"""
02161 return _SyFi.VectorLagrange_set_size(self, *args)
02162
02163 def compute_basis_functions(self):
02164 """compute_basis_functions(self)"""
02165 return _SyFi.VectorLagrange_compute_basis_functions(self)
02166
02167 VectorLagrange_swigregister = _SyFi.VectorLagrange_swigregister
02168 VectorLagrange_swigregister(VectorLagrange)
02169
02170 class TensorLagrange(StandardFE):
02171 """Proxy of C++ SyFi::TensorLagrange class"""
02172 __swig_setmethods__ = {}
02173 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02174 __setattr__ = lambda self, name, value: _swig_setattr(self, TensorLagrange, name, value)
02175 __swig_getmethods__ = {}
02176 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02177 __getattr__ = lambda self, name: _swig_getattr(self, TensorLagrange, name)
02178 __repr__ = _swig_repr
02179 def __init__(self, *args):
02180 """
02181 __init__(self) -> TensorLagrange
02182 __init__(self, Polygon p, unsigned int order = 1, unsigned int size = 0) -> TensorLagrange
02183 __init__(self, Polygon p, unsigned int order = 1) -> TensorLagrange
02184 __init__(self, Polygon p) -> TensorLagrange
02185 """
02186 this = _SyFi.new_TensorLagrange(*args)
02187 try: self.this.append(this)
02188 except: self.this = this
02189 __swig_destroy__ = _SyFi.delete_TensorLagrange
02190 __del__ = lambda self : None;
02191 def set_size(self, *args):
02192 """set_size(self, unsigned int size_)"""
02193 return _SyFi.TensorLagrange_set_size(self, *args)
02194
02195 def compute_basis_functions(self):
02196 """compute_basis_functions(self)"""
02197 return _SyFi.TensorLagrange_compute_basis_functions(self)
02198
02199 TensorLagrange_swigregister = _SyFi.TensorLagrange_swigregister
02200 TensorLagrange_swigregister(TensorLagrange)
02201
02202
02203 def lagrange(*args):
02204 """lagrange(unsigned int order, Polygon p, string a) -> GiNaC::ex"""
02205 return _SyFi.lagrange(*args)
02206
02207 def lagrangev(*args):
02208 """
02209 lagrangev(unsigned int no_fields, unsigned int order, Polygon p,
02210 string a) -> GiNaC::lst
02211 """
02212 return _SyFi.lagrangev(*args)
02213 class Dof(_object):
02214 """Proxy of C++ SyFi::Dof class"""
02215 __swig_setmethods__ = {}
02216 __setattr__ = lambda self, name, value: _swig_setattr(self, Dof, name, value)
02217 __swig_getmethods__ = {}
02218 __getattr__ = lambda self, name: _swig_getattr(self, Dof, name)
02219 __repr__ = _swig_repr
02220 def __init__(self, create_glob2dof = False, create_glob2loc = False):
02221 """
02222 __init__(self, bool create_glob2dof = False, bool create_glob2loc = False) -> Dof
02223 __init__(self, bool create_glob2dof = False) -> Dof
02224 __init__(self) -> Dof
02225 """
02226 this = _SyFi.new_Dof(create_glob2dof, create_glob2loc)
02227 try: self.this.append(this)
02228 except: self.this = this
02229 __swig_destroy__ = _SyFi.delete_Dof
02230 __del__ = lambda self : None;
02231 def clear(self):
02232 """clear(self)"""
02233 return _SyFi.Dof_clear(self)
02234
02235 def insert_dof(self, *args):
02236 """insert_dof(self, unsigned int e, unsigned int i, GiNaC::ex Li) -> unsigned int"""
02237 return _SyFi.Dof_insert_dof(self, *args)
02238
02239 def size(self):
02240 """size(self) -> unsigned int"""
02241 return _SyFi.Dof_size(self)
02242
02243 def num_elements(self):
02244 """num_elements(self) -> unsigned int"""
02245 return _SyFi.Dof_num_elements(self)
02246
02247 def max_dofs_per_element(self):
02248 """max_dofs_per_element(self) -> unsigned int"""
02249 return _SyFi.Dof_max_dofs_per_element(self)
02250
02251 def glob_dof(self, *args):
02252 """
02253 glob_dof(self, unsigned int e, unsigned int i) -> unsigned int
02254 glob_dof(self, GiNaC::ex Lj) -> unsigned int
02255 glob_dof(self, unsigned int j) -> GiNaC::ex
02256 """
02257 return _SyFi.Dof_glob_dof(self, *args)
02258
02259 def glob2loc(self, *args):
02260 """glob2loc(self, unsigned int j) -> vector_ii"""
02261 return _SyFi.Dof_glob2loc(self, *args)
02262
02263 Dof_swigregister = _SyFi.Dof_swigregister
02264 Dof_swigregister(Dof)
02265
02266 class CrouzeixRaviart(StandardFE):
02267 """Proxy of C++ SyFi::CrouzeixRaviart class"""
02268 __swig_setmethods__ = {}
02269 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02270 __setattr__ = lambda self, name, value: _swig_setattr(self, CrouzeixRaviart, name, value)
02271 __swig_getmethods__ = {}
02272 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02273 __getattr__ = lambda self, name: _swig_getattr(self, CrouzeixRaviart, name)
02274 __repr__ = _swig_repr
02275 def __init__(self, *args):
02276 """
02277 __init__(self) -> CrouzeixRaviart
02278 __init__(self, Polygon p, unsigned int order = 1) -> CrouzeixRaviart
02279 __init__(self, Polygon p) -> CrouzeixRaviart
02280 """
02281 this = _SyFi.new_CrouzeixRaviart(*args)
02282 try: self.this.append(this)
02283 except: self.this = this
02284 __swig_destroy__ = _SyFi.delete_CrouzeixRaviart
02285 __del__ = lambda self : None;
02286 def compute_basis_functions(self):
02287 """compute_basis_functions(self)"""
02288 return _SyFi.CrouzeixRaviart_compute_basis_functions(self)
02289
02290 CrouzeixRaviart_swigregister = _SyFi.CrouzeixRaviart_swigregister
02291 CrouzeixRaviart_swigregister(CrouzeixRaviart)
02292
02293 class VectorCrouzeixRaviart(StandardFE):
02294 """Proxy of C++ SyFi::VectorCrouzeixRaviart class"""
02295 __swig_setmethods__ = {}
02296 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02297 __setattr__ = lambda self, name, value: _swig_setattr(self, VectorCrouzeixRaviart, name, value)
02298 __swig_getmethods__ = {}
02299 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02300 __getattr__ = lambda self, name: _swig_getattr(self, VectorCrouzeixRaviart, name)
02301 __repr__ = _swig_repr
02302 def __init__(self, *args):
02303 """
02304 __init__(self) -> VectorCrouzeixRaviart
02305 __init__(self, Polygon p, unsigned int order = 1, unsigned int size = -1) -> VectorCrouzeixRaviart
02306 __init__(self, Polygon p, unsigned int order = 1) -> VectorCrouzeixRaviart
02307 __init__(self, Polygon p) -> VectorCrouzeixRaviart
02308 """
02309 this = _SyFi.new_VectorCrouzeixRaviart(*args)
02310 try: self.this.append(this)
02311 except: self.this = this
02312 __swig_destroy__ = _SyFi.delete_VectorCrouzeixRaviart
02313 __del__ = lambda self : None;
02314 def set_size(self, *args):
02315 """set_size(self, unsigned int size_)"""
02316 return _SyFi.VectorCrouzeixRaviart_set_size(self, *args)
02317
02318 def compute_basis_functions(self):
02319 """compute_basis_functions(self)"""
02320 return _SyFi.VectorCrouzeixRaviart_compute_basis_functions(self)
02321
02322 VectorCrouzeixRaviart_swigregister = _SyFi.VectorCrouzeixRaviart_swigregister
02323 VectorCrouzeixRaviart_swigregister(VectorCrouzeixRaviart)
02324
02325 class P0(StandardFE):
02326 """Proxy of C++ SyFi::P0 class"""
02327 __swig_setmethods__ = {}
02328 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02329 __setattr__ = lambda self, name, value: _swig_setattr(self, P0, name, value)
02330 __swig_getmethods__ = {}
02331 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02332 __getattr__ = lambda self, name: _swig_getattr(self, P0, name)
02333 __repr__ = _swig_repr
02334 def __init__(self, *args):
02335 """
02336 __init__(self) -> P0
02337 __init__(self, Polygon p, unsigned int order = 0) -> P0
02338 __init__(self, Polygon p) -> P0
02339 """
02340 this = _SyFi.new_P0(*args)
02341 try: self.this.append(this)
02342 except: self.this = this
02343 __swig_destroy__ = _SyFi.delete_P0
02344 __del__ = lambda self : None;
02345 def compute_basis_functions(self):
02346 """compute_basis_functions(self)"""
02347 return _SyFi.P0_compute_basis_functions(self)
02348
02349 P0_swigregister = _SyFi.P0_swigregister
02350 P0_swigregister(P0)
02351
02352 class VectorP0(StandardFE):
02353 """Proxy of C++ SyFi::VectorP0 class"""
02354 __swig_setmethods__ = {}
02355 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02356 __setattr__ = lambda self, name, value: _swig_setattr(self, VectorP0, name, value)
02357 __swig_getmethods__ = {}
02358 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02359 __getattr__ = lambda self, name: _swig_getattr(self, VectorP0, name)
02360 __repr__ = _swig_repr
02361 def __init__(self, *args):
02362 """
02363 __init__(self) -> VectorP0
02364 __init__(self, Polygon p, unsigned int order = 0, unsigned int size = 0) -> VectorP0
02365 __init__(self, Polygon p, unsigned int order = 0) -> VectorP0
02366 __init__(self, Polygon p) -> VectorP0
02367 """
02368 this = _SyFi.new_VectorP0(*args)
02369 try: self.this.append(this)
02370 except: self.this = this
02371 __swig_destroy__ = _SyFi.delete_VectorP0
02372 __del__ = lambda self : None;
02373 def set_size(self, *args):
02374 """set_size(self, unsigned int size_)"""
02375 return _SyFi.VectorP0_set_size(self, *args)
02376
02377 def compute_basis_functions(self):
02378 """compute_basis_functions(self)"""
02379 return _SyFi.VectorP0_compute_basis_functions(self)
02380
02381 VectorP0_swigregister = _SyFi.VectorP0_swigregister
02382 VectorP0_swigregister(VectorP0)
02383
02384 class TensorP0(StandardFE):
02385 """Proxy of C++ SyFi::TensorP0 class"""
02386 __swig_setmethods__ = {}
02387 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02388 __setattr__ = lambda self, name, value: _swig_setattr(self, TensorP0, name, value)
02389 __swig_getmethods__ = {}
02390 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02391 __getattr__ = lambda self, name: _swig_getattr(self, TensorP0, name)
02392 __repr__ = _swig_repr
02393 def __init__(self, *args):
02394 """
02395 __init__(self) -> TensorP0
02396 __init__(self, Polygon p, unsigned int order = 0, unsigned int size = 0) -> TensorP0
02397 __init__(self, Polygon p, unsigned int order = 0) -> TensorP0
02398 __init__(self, Polygon p) -> TensorP0
02399 """
02400 this = _SyFi.new_TensorP0(*args)
02401 try: self.this.append(this)
02402 except: self.this = this
02403 __swig_destroy__ = _SyFi.delete_TensorP0
02404 __del__ = lambda self : None;
02405 def set_size(self, *args):
02406 """set_size(self, unsigned int size_)"""
02407 return _SyFi.TensorP0_set_size(self, *args)
02408
02409 def compute_basis_functions(self):
02410 """compute_basis_functions(self)"""
02411 return _SyFi.TensorP0_compute_basis_functions(self)
02412
02413 TensorP0_swigregister = _SyFi.TensorP0_swigregister
02414 TensorP0_swigregister(TensorP0)
02415
02416 class RaviartThomas(StandardFE):
02417 """Proxy of C++ SyFi::RaviartThomas class"""
02418 __swig_setmethods__ = {}
02419 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02420 __setattr__ = lambda self, name, value: _swig_setattr(self, RaviartThomas, name, value)
02421 __swig_getmethods__ = {}
02422 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02423 __getattr__ = lambda self, name: _swig_getattr(self, RaviartThomas, name)
02424 __repr__ = _swig_repr
02425 __swig_setmethods__["pointwise"] = _SyFi.RaviartThomas_pointwise_set
02426 __swig_getmethods__["pointwise"] = _SyFi.RaviartThomas_pointwise_get
02427 if _newclass:pointwise = _swig_property(_SyFi.RaviartThomas_pointwise_get, _SyFi.RaviartThomas_pointwise_set)
02428 __swig_setmethods__["dof_repr"] = _SyFi.RaviartThomas_dof_repr_set
02429 __swig_getmethods__["dof_repr"] = _SyFi.RaviartThomas_dof_repr_get
02430 if _newclass:dof_repr = _swig_property(_SyFi.RaviartThomas_dof_repr_get, _SyFi.RaviartThomas_dof_repr_set)
02431 def __init__(self, *args):
02432 """
02433 __init__(self) -> RaviartThomas
02434 __init__(self, Polygon p, int order = 1, bool pointwise = True) -> RaviartThomas
02435 __init__(self, Polygon p, int order = 1) -> RaviartThomas
02436 __init__(self, Polygon p) -> RaviartThomas
02437 """
02438 this = _SyFi.new_RaviartThomas(*args)
02439 try: self.this.append(this)
02440 except: self.this = this
02441 __swig_destroy__ = _SyFi.delete_RaviartThomas
02442 __del__ = lambda self : None;
02443 def compute_basis_functions(self):
02444 """compute_basis_functions(self)"""
02445 return _SyFi.RaviartThomas_compute_basis_functions(self)
02446
02447 RaviartThomas_swigregister = _SyFi.RaviartThomas_swigregister
02448 RaviartThomas_swigregister(RaviartThomas)
02449
02450 class DiscontinuousLagrange(Lagrange):
02451 """Proxy of C++ SyFi::DiscontinuousLagrange class"""
02452 __swig_setmethods__ = {}
02453 for _s in [Lagrange]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02454 __setattr__ = lambda self, name, value: _swig_setattr(self, DiscontinuousLagrange, name, value)
02455 __swig_getmethods__ = {}
02456 for _s in [Lagrange]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02457 __getattr__ = lambda self, name: _swig_getattr(self, DiscontinuousLagrange, name)
02458 __repr__ = _swig_repr
02459 def __init__(self, *args):
02460 """
02461 __init__(self) -> DiscontinuousLagrange
02462 __init__(self, Polygon p, unsigned int order = 1) -> DiscontinuousLagrange
02463 __init__(self, Polygon p) -> DiscontinuousLagrange
02464 """
02465 this = _SyFi.new_DiscontinuousLagrange(*args)
02466 try: self.this.append(this)
02467 except: self.this = this
02468 __swig_destroy__ = _SyFi.delete_DiscontinuousLagrange
02469 __del__ = lambda self : None;
02470 def set_element_number(self, *args):
02471 """set_element_number(self, unsigned int element)"""
02472 return _SyFi.DiscontinuousLagrange_set_element_number(self, *args)
02473
02474 def compute_basis_functions(self):
02475 """compute_basis_functions(self)"""
02476 return _SyFi.DiscontinuousLagrange_compute_basis_functions(self)
02477
02478 DiscontinuousLagrange_swigregister = _SyFi.DiscontinuousLagrange_swigregister
02479 DiscontinuousLagrange_swigregister(DiscontinuousLagrange)
02480
02481 class VectorDiscontinuousLagrange(VectorLagrange):
02482 """Proxy of C++ SyFi::VectorDiscontinuousLagrange class"""
02483 __swig_setmethods__ = {}
02484 for _s in [VectorLagrange]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02485 __setattr__ = lambda self, name, value: _swig_setattr(self, VectorDiscontinuousLagrange, name, value)
02486 __swig_getmethods__ = {}
02487 for _s in [VectorLagrange]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02488 __getattr__ = lambda self, name: _swig_getattr(self, VectorDiscontinuousLagrange, name)
02489 __repr__ = _swig_repr
02490 def __init__(self, *args):
02491 """
02492 __init__(self) -> VectorDiscontinuousLagrange
02493 __init__(self, Polygon p, unsigned int order = 1) -> VectorDiscontinuousLagrange
02494 __init__(self, Polygon p) -> VectorDiscontinuousLagrange
02495 """
02496 this = _SyFi.new_VectorDiscontinuousLagrange(*args)
02497 try: self.this.append(this)
02498 except: self.this = this
02499 __swig_destroy__ = _SyFi.delete_VectorDiscontinuousLagrange
02500 __del__ = lambda self : None;
02501 def set_element_number(self, *args):
02502 """set_element_number(self, unsigned int element)"""
02503 return _SyFi.VectorDiscontinuousLagrange_set_element_number(self, *args)
02504
02505 def set_size(self, *args):
02506 """set_size(self, unsigned int size_)"""
02507 return _SyFi.VectorDiscontinuousLagrange_set_size(self, *args)
02508
02509 def compute_basis_functions(self):
02510 """compute_basis_functions(self)"""
02511 return _SyFi.VectorDiscontinuousLagrange_compute_basis_functions(self)
02512
02513 VectorDiscontinuousLagrange_swigregister = _SyFi.VectorDiscontinuousLagrange_swigregister
02514 VectorDiscontinuousLagrange_swigregister(VectorDiscontinuousLagrange)
02515
02516 class Hermite(StandardFE):
02517 """Proxy of C++ SyFi::Hermite class"""
02518 __swig_setmethods__ = {}
02519 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02520 __setattr__ = lambda self, name, value: _swig_setattr(self, Hermite, name, value)
02521 __swig_getmethods__ = {}
02522 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02523 __getattr__ = lambda self, name: _swig_getattr(self, Hermite, name)
02524 __repr__ = _swig_repr
02525 def __init__(self, *args):
02526 """
02527 __init__(self) -> Hermite
02528 __init__(self, Polygon p, int order = 1) -> Hermite
02529 __init__(self, Polygon p) -> Hermite
02530 """
02531 this = _SyFi.new_Hermite(*args)
02532 try: self.this.append(this)
02533 except: self.this = this
02534 __swig_destroy__ = _SyFi.delete_Hermite
02535 __del__ = lambda self : None;
02536 def compute_basis_functions(self):
02537 """compute_basis_functions(self)"""
02538 return _SyFi.Hermite_compute_basis_functions(self)
02539
02540 Hermite_swigregister = _SyFi.Hermite_swigregister
02541 Hermite_swigregister(Hermite)
02542
02543 class Nedelec(StandardFE):
02544 """Proxy of C++ SyFi::Nedelec class"""
02545 __swig_setmethods__ = {}
02546 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02547 __setattr__ = lambda self, name, value: _swig_setattr(self, Nedelec, name, value)
02548 __swig_getmethods__ = {}
02549 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02550 __getattr__ = lambda self, name: _swig_getattr(self, Nedelec, name)
02551 __repr__ = _swig_repr
02552 def __init__(self, *args):
02553 """
02554 __init__(self) -> Nedelec
02555 __init__(self, Polygon p, int order = 1) -> Nedelec
02556 __init__(self, Polygon p) -> Nedelec
02557 """
02558 this = _SyFi.new_Nedelec(*args)
02559 try: self.this.append(this)
02560 except: self.this = this
02561 __swig_destroy__ = _SyFi.delete_Nedelec
02562 __del__ = lambda self : None;
02563 def compute_basis_functions(self):
02564 """compute_basis_functions(self)"""
02565 return _SyFi.Nedelec_compute_basis_functions(self)
02566
02567 Nedelec_swigregister = _SyFi.Nedelec_swigregister
02568 Nedelec_swigregister(Nedelec)
02569
02570 class Nedelec2Hdiv(StandardFE):
02571 """Proxy of C++ SyFi::Nedelec2Hdiv class"""
02572 __swig_setmethods__ = {}
02573 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02574 __setattr__ = lambda self, name, value: _swig_setattr(self, Nedelec2Hdiv, name, value)
02575 __swig_getmethods__ = {}
02576 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02577 __getattr__ = lambda self, name: _swig_getattr(self, Nedelec2Hdiv, name)
02578 __repr__ = _swig_repr
02579 __swig_setmethods__["dof_repr"] = _SyFi.Nedelec2Hdiv_dof_repr_set
02580 __swig_getmethods__["dof_repr"] = _SyFi.Nedelec2Hdiv_dof_repr_get
02581 if _newclass:dof_repr = _swig_property(_SyFi.Nedelec2Hdiv_dof_repr_get, _SyFi.Nedelec2Hdiv_dof_repr_set)
02582 def __init__(self, *args):
02583 """
02584 __init__(self) -> Nedelec2Hdiv
02585 __init__(self, Polygon p, unsigned int order = 1) -> Nedelec2Hdiv
02586 __init__(self, Polygon p) -> Nedelec2Hdiv
02587 """
02588 this = _SyFi.new_Nedelec2Hdiv(*args)
02589 try: self.this.append(this)
02590 except: self.this = this
02591 __swig_destroy__ = _SyFi.delete_Nedelec2Hdiv
02592 __del__ = lambda self : None;
02593 def compute_basis_functions(self):
02594 """compute_basis_functions(self)"""
02595 return _SyFi.Nedelec2Hdiv_compute_basis_functions(self)
02596
02597 Nedelec2Hdiv_swigregister = _SyFi.Nedelec2Hdiv_swigregister
02598 Nedelec2Hdiv_swigregister(Nedelec2Hdiv)
02599
02600 class Bubble(StandardFE):
02601 """Proxy of C++ SyFi::Bubble class"""
02602 __swig_setmethods__ = {}
02603 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02604 __setattr__ = lambda self, name, value: _swig_setattr(self, Bubble, name, value)
02605 __swig_getmethods__ = {}
02606 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02607 __getattr__ = lambda self, name: _swig_getattr(self, Bubble, name)
02608 __repr__ = _swig_repr
02609 def __init__(self, *args):
02610 """
02611 __init__(self) -> Bubble
02612 __init__(self, Polygon p, unsigned int order = 3) -> Bubble
02613 __init__(self, Polygon p) -> Bubble
02614 """
02615 this = _SyFi.new_Bubble(*args)
02616 try: self.this.append(this)
02617 except: self.this = this
02618 __swig_destroy__ = _SyFi.delete_Bubble
02619 __del__ = lambda self : None;
02620 def compute_basis_functions(self):
02621 """compute_basis_functions(self)"""
02622 return _SyFi.Bubble_compute_basis_functions(self)
02623
02624 Bubble_swigregister = _SyFi.Bubble_swigregister
02625 Bubble_swigregister(Bubble)
02626
02627
02628 def compute_Poisson_element_matrix(*args):
02629 """compute_Poisson_element_matrix(FE fe, Dof dof, std::map<(std::pair<(unsigned int,unsigned int)>,GiNaC::ex,std::less<(std::pair<(unsigned int,unsigned int)>)>,std::allocator<(std::pair<(q(const).std::pair<(unsigned int,unsigned int)>,GiNaC::ex)>)>)> A)"""
02630 return _SyFi.compute_Poisson_element_matrix(*args)
02631
02632 def compute_Stokes_element_matrix(*args):
02633 """compute_Stokes_element_matrix(FE v_fe, FE p_fe, Dof dof, std::map<(std::pair<(unsigned int,unsigned int)>,GiNaC::ex,std::less<(std::pair<(unsigned int,unsigned int)>)>,std::allocator<(std::pair<(q(const).std::pair<(unsigned int,unsigned int)>,GiNaC::ex)>)>)> A)"""
02634 return _SyFi.compute_Stokes_element_matrix(*args)
02635
02636 def compute_mixed_Poisson_element_matrix(*args):
02637 """compute_mixed_Poisson_element_matrix(FE v_fe, FE p_fe, Dof dof, std::map<(std::pair<(unsigned int,unsigned int)>,GiNaC::ex,std::less<(std::pair<(unsigned int,unsigned int)>)>,std::allocator<(std::pair<(q(const).std::pair<(unsigned int,unsigned int)>,GiNaC::ex)>)>)> A)"""
02638 return _SyFi.compute_mixed_Poisson_element_matrix(*args)
02639 class ArnoldFalkWintherWeakSymSigma(StandardFE):
02640 """Proxy of C++ SyFi::ArnoldFalkWintherWeakSymSigma class"""
02641 __swig_setmethods__ = {}
02642 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02643 __setattr__ = lambda self, name, value: _swig_setattr(self, ArnoldFalkWintherWeakSymSigma, name, value)
02644 __swig_getmethods__ = {}
02645 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02646 __getattr__ = lambda self, name: _swig_getattr(self, ArnoldFalkWintherWeakSymSigma, name)
02647 __repr__ = _swig_repr
02648 def __init__(self, *args):
02649 """
02650 __init__(self) -> ArnoldFalkWintherWeakSymSigma
02651 __init__(self, Polygon p, int order = 1) -> ArnoldFalkWintherWeakSymSigma
02652 __init__(self, Polygon p) -> ArnoldFalkWintherWeakSymSigma
02653 """
02654 this = _SyFi.new_ArnoldFalkWintherWeakSymSigma(*args)
02655 try: self.this.append(this)
02656 except: self.this = this
02657 __swig_destroy__ = _SyFi.delete_ArnoldFalkWintherWeakSymSigma
02658 __del__ = lambda self : None;
02659 def compute_basis_functions(self):
02660 """compute_basis_functions(self)"""
02661 return _SyFi.ArnoldFalkWintherWeakSymSigma_compute_basis_functions(self)
02662
02663 ArnoldFalkWintherWeakSymSigma_swigregister = _SyFi.ArnoldFalkWintherWeakSymSigma_swigregister
02664 ArnoldFalkWintherWeakSymSigma_swigregister(ArnoldFalkWintherWeakSymSigma)
02665
02666 def usage(*args):
02667 """
02668 usage(FE fe)
02669 usage(FE v_fe, FE p_fe)
02670 """
02671 return _SyFi.usage(*args)
02672
02673 class ArnoldFalkWintherWeakSymU(StandardFE):
02674 """Proxy of C++ SyFi::ArnoldFalkWintherWeakSymU class"""
02675 __swig_setmethods__ = {}
02676 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02677 __setattr__ = lambda self, name, value: _swig_setattr(self, ArnoldFalkWintherWeakSymU, name, value)
02678 __swig_getmethods__ = {}
02679 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02680 __getattr__ = lambda self, name: _swig_getattr(self, ArnoldFalkWintherWeakSymU, name)
02681 __repr__ = _swig_repr
02682 def __init__(self, *args):
02683 """
02684 __init__(self) -> ArnoldFalkWintherWeakSymU
02685 __init__(self, Polygon p, int order = 1) -> ArnoldFalkWintherWeakSymU
02686 __init__(self, Polygon p) -> ArnoldFalkWintherWeakSymU
02687 """
02688 this = _SyFi.new_ArnoldFalkWintherWeakSymU(*args)
02689 try: self.this.append(this)
02690 except: self.this = this
02691 __swig_destroy__ = _SyFi.delete_ArnoldFalkWintherWeakSymU
02692 __del__ = lambda self : None;
02693 def compute_basis_functions(self):
02694 """compute_basis_functions(self)"""
02695 return _SyFi.ArnoldFalkWintherWeakSymU_compute_basis_functions(self)
02696
02697 ArnoldFalkWintherWeakSymU_swigregister = _SyFi.ArnoldFalkWintherWeakSymU_swigregister
02698 ArnoldFalkWintherWeakSymU_swigregister(ArnoldFalkWintherWeakSymU)
02699
02700 class ArnoldFalkWintherWeakSymP(StandardFE):
02701 """Proxy of C++ SyFi::ArnoldFalkWintherWeakSymP class"""
02702 __swig_setmethods__ = {}
02703 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02704 __setattr__ = lambda self, name, value: _swig_setattr(self, ArnoldFalkWintherWeakSymP, name, value)
02705 __swig_getmethods__ = {}
02706 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02707 __getattr__ = lambda self, name: _swig_getattr(self, ArnoldFalkWintherWeakSymP, name)
02708 __repr__ = _swig_repr
02709 def __init__(self, *args):
02710 """
02711 __init__(self) -> ArnoldFalkWintherWeakSymP
02712 __init__(self, Polygon p, int order = 1) -> ArnoldFalkWintherWeakSymP
02713 __init__(self, Polygon p) -> ArnoldFalkWintherWeakSymP
02714 """
02715 this = _SyFi.new_ArnoldFalkWintherWeakSymP(*args)
02716 try: self.this.append(this)
02717 except: self.this = this
02718 __swig_destroy__ = _SyFi.delete_ArnoldFalkWintherWeakSymP
02719 __del__ = lambda self : None;
02720 def compute_basis_functions(self):
02721 """compute_basis_functions(self)"""
02722 return _SyFi.ArnoldFalkWintherWeakSymP_compute_basis_functions(self)
02723
02724 ArnoldFalkWintherWeakSymP_swigregister = _SyFi.ArnoldFalkWintherWeakSymP_swigregister
02725 ArnoldFalkWintherWeakSymP_swigregister(ArnoldFalkWintherWeakSymP)
02726
02727 class Robust(StandardFE):
02728 """Proxy of C++ SyFi::Robust class"""
02729 __swig_setmethods__ = {}
02730 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02731 __setattr__ = lambda self, name, value: _swig_setattr(self, Robust, name, value)
02732 __swig_getmethods__ = {}
02733 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02734 __getattr__ = lambda self, name: _swig_getattr(self, Robust, name)
02735 __repr__ = _swig_repr
02736 __swig_setmethods__["pointwise"] = _SyFi.Robust_pointwise_set
02737 __swig_getmethods__["pointwise"] = _SyFi.Robust_pointwise_get
02738 if _newclass:pointwise = _swig_property(_SyFi.Robust_pointwise_get, _SyFi.Robust_pointwise_set)
02739 __swig_setmethods__["dof_repr"] = _SyFi.Robust_dof_repr_set
02740 __swig_getmethods__["dof_repr"] = _SyFi.Robust_dof_repr_get
02741 if _newclass:dof_repr = _swig_property(_SyFi.Robust_dof_repr_get, _SyFi.Robust_dof_repr_set)
02742 def __init__(self, *args):
02743 """
02744 __init__(self) -> Robust
02745 __init__(self, Polygon p, unsigned int order = 0, bool pointwise = True) -> Robust
02746 __init__(self, Polygon p, unsigned int order = 0) -> Robust
02747 __init__(self, Polygon p) -> Robust
02748 """
02749 this = _SyFi.new_Robust(*args)
02750 try: self.this.append(this)
02751 except: self.this = this
02752 __swig_destroy__ = _SyFi.delete_Robust
02753 __del__ = lambda self : None;
02754 def compute_basis_functions(self):
02755 """compute_basis_functions(self)"""
02756 return _SyFi.Robust_compute_basis_functions(self)
02757
02758 def compute_basis_functions_old(self):
02759 """compute_basis_functions_old(self)"""
02760 return _SyFi.Robust_compute_basis_functions_old(self)
02761
02762 Robust_swigregister = _SyFi.Robust_swigregister
02763 Robust_swigregister(Robust)
02764
02765 class MixedFE(FE):
02766 """Proxy of C++ SyFi::MixedFE class"""
02767 __swig_setmethods__ = {}
02768 for _s in [FE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02769 __setattr__ = lambda self, name, value: _swig_setattr(self, MixedFE, name, value)
02770 __swig_getmethods__ = {}
02771 for _s in [FE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02772 __getattr__ = lambda self, name: _swig_getattr(self, MixedFE, name)
02773 __repr__ = _swig_repr
02774 __swig_setmethods__["mfe"] = _SyFi.MixedFE_mfe_set
02775 __swig_getmethods__["mfe"] = _SyFi.MixedFE_mfe_get
02776 if _newclass:mfe = _swig_property(_SyFi.MixedFE_mfe_get, _SyFi.MixedFE_mfe_set)
02777 def __init__(self, *args):
02778 """
02779 __init__(self) -> MixedFE
02780 __init__(self, StandardFE fe1, StandardFE fe2) -> MixedFE
02781 """
02782 this = _SyFi.new_MixedFE(*args)
02783 try: self.this.append(this)
02784 except: self.this = this
02785 __swig_destroy__ = _SyFi.delete_MixedFE
02786 __del__ = lambda self : None;
02787 def set_polygon(self, *args):
02788 """set_polygon(self, Polygon p)"""
02789 return _SyFi.MixedFE_set_polygon(self, *args)
02790
02791 def get_polygon(self):
02792 """get_polygon(self) -> Polygon"""
02793 return _SyFi.MixedFE_get_polygon(self)
02794
02795 def compute_basis_functions(self):
02796 """compute_basis_functions(self)"""
02797 return _SyFi.MixedFE_compute_basis_functions(self)
02798
02799 def get(self, *args):
02800 """get(self, unsigned int i) -> StandardFE"""
02801 return _SyFi.MixedFE_get(self, *args)
02802
02803 def append(self, *args):
02804 """append(self, StandardFE fe)"""
02805 return _SyFi.MixedFE_append(self, *args)
02806
02807 def N(self, *args):
02808 """N(self, unsigned int i) -> GiNaC::ex"""
02809 return _SyFi.MixedFE_N(self, *args)
02810
02811 def dof(self, *args):
02812 """dof(self, unsigned int i) -> GiNaC::ex"""
02813 return _SyFi.MixedFE_dof(self, *args)
02814
02815 def nbf(self):
02816 """nbf(self) -> unsigned int"""
02817 return _SyFi.MixedFE_nbf(self)
02818
02819 def str(self):
02820 """str(self) -> string"""
02821 return _SyFi.MixedFE_str(self)
02822
02823 MixedFE_swigregister = _SyFi.MixedFE_swigregister
02824 MixedFE_swigregister(MixedFE)
02825
02826 class SpaceTimeDomain(Polygon):
02827 """Proxy of C++ SyFi::SpaceTimeDomain class"""
02828 __swig_setmethods__ = {}
02829 for _s in [Polygon]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02830 __setattr__ = lambda self, name, value: _swig_setattr(self, SpaceTimeDomain, name, value)
02831 __swig_getmethods__ = {}
02832 for _s in [Polygon]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02833 __getattr__ = lambda self, name: _swig_getattr(self, SpaceTimeDomain, name)
02834 __repr__ = _swig_repr
02835 def __init__(self, *args):
02836 """
02837 __init__(self, Line time_line_, Polygon polygon_) -> SpaceTimeDomain
02838 __init__(self, SpaceTimeDomain space_time_domain_) -> SpaceTimeDomain
02839 """
02840 this = _SyFi.new_SpaceTimeDomain(*args)
02841 try: self.this.append(this)
02842 except: self.this = this
02843 def get_space_domain(self):
02844 """get_space_domain(self) -> Polygon"""
02845 return _SyFi.SpaceTimeDomain_get_space_domain(self)
02846
02847 def get_time_domain(self):
02848 """get_time_domain(self) -> Line"""
02849 return _SyFi.SpaceTimeDomain_get_time_domain(self)
02850
02851 def no_space_dim(self):
02852 """no_space_dim(self) -> unsigned int"""
02853 return _SyFi.SpaceTimeDomain_no_space_dim(self)
02854
02855 def line(self, *args):
02856 """line(self, unsigned int i) -> Line"""
02857 return _SyFi.SpaceTimeDomain_line(self, *args)
02858
02859 def repr(self, *args):
02860 """
02861 repr(self, Repr_format arg0 = SUBS_PERFORMED) -> GiNaC::ex
02862 repr(self) -> GiNaC::ex
02863 """
02864 return _SyFi.SpaceTimeDomain_repr(self, *args)
02865
02866 def str(self):
02867 """str(self) -> string"""
02868 return _SyFi.SpaceTimeDomain_str(self)
02869
02870 def integrate(self, *args):
02871 """
02872 integrate(self, GiNaC::ex f, Repr_format format = SUBS_PERFORMED) -> GiNaC::ex
02873 integrate(self, GiNaC::ex f) -> GiNaC::ex
02874 """
02875 return _SyFi.SpaceTimeDomain_integrate(self, *args)
02876
02877 def copy(self):
02878 """copy(self) -> SpaceTimeDomain"""
02879 return _SyFi.SpaceTimeDomain_copy(self)
02880
02881 __swig_destroy__ = _SyFi.delete_SpaceTimeDomain
02882 __del__ = lambda self : None;
02883 SpaceTimeDomain_swigregister = _SyFi.SpaceTimeDomain_swigregister
02884 SpaceTimeDomain_swigregister(SpaceTimeDomain)
02885
02886 class SpaceTimeElement(StandardFE):
02887 """Proxy of C++ SyFi::SpaceTimeElement class"""
02888 __swig_setmethods__ = {}
02889 for _s in [StandardFE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
02890 __setattr__ = lambda self, name, value: _swig_setattr(self, SpaceTimeElement, name, value)
02891 __swig_getmethods__ = {}
02892 for _s in [StandardFE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
02893 __getattr__ = lambda self, name: _swig_getattr(self, SpaceTimeElement, name)
02894 __repr__ = _swig_repr
02895 def __init__(self, *args):
02896 """
02897 __init__(self) -> SpaceTimeElement
02898 __init__(self, Line time_line_, unsigned int order_, StandardFE fe_) -> SpaceTimeElement
02899 """
02900 this = _SyFi.new_SpaceTimeElement(*args)
02901 try: self.this.append(this)
02902 except: self.this = this
02903 __swig_destroy__ = _SyFi.delete_SpaceTimeElement
02904 __del__ = lambda self : None;
02905 def set_time_domain(self, *args):
02906 """set_time_domain(self, Line line)"""
02907 return _SyFi.SpaceTimeElement_set_time_domain(self, *args)
02908
02909 def set_order_in_time(self, *args):
02910 """set_order_in_time(self, unsigned int order)"""
02911 return _SyFi.SpaceTimeElement_set_order_in_time(self, *args)
02912
02913 def set_spatial_element(self, *args):
02914 """set_spatial_element(self, StandardFE fe)"""
02915 return _SyFi.SpaceTimeElement_set_spatial_element(self, *args)
02916
02917 def compute_basis_functions(self):
02918 """compute_basis_functions(self)"""
02919 return _SyFi.SpaceTimeElement_compute_basis_functions(self)
02920
02921 SpaceTimeElement_swigregister = _SyFi.SpaceTimeElement_swigregister
02922 SpaceTimeElement_swigregister(SpaceTimeElement)
02923
02924
02925