Scraping an Existing Site
This is an experimental feature; use at your own risk.
- Once you have the sitemap complete, that represents an existing website.
- Compile using
--format=json
to get the compile file.
- Pass that compiled file to scrape to scrape the website based on the sitemap.
- Follow the instructions in the output.
./vendor/bin/vismap website.json --format=json
./vendor/bin/scrape website.compile.json


from __future__ import absolute_import # The default socket timeout, used by httplib to indicate that no timeout was # specified by the user from socket import _GLOBAL_DEFAULT_TIMEOUT import time from ..exceptions import TimeoutStateError # A sentinel value to indicate that no timeout was specified by the user in # urllib3 _Default = object() # Use time.monotonic if available. current_time = getattr(time, "monotonic", time.time) class Timeout(object): """ Timeout configuration. Timeouts can be defined as a default for a pool:: timeout = Timeout(connect=2.0, read=7.0) http = PoolManager(timeout=timeout) response = http.request('GET', 'http://example.com/') Or per-request (which overrides the default for the pool):: response = http.request('GET', 'http://example.com/', timeout=Timeout(10)) Timeouts can be disabled by setting all the parameters to ``None``:: no_timeout = Timeout(connect=None, read=None) response = http.request('GET', 'http://example.com/, timeout=no_timeout) :param total: This combines the connect and read timeouts into one; the read timeout will be set to the time leftover from the connect attempt. In the event that both a connect timeout and a total are specified, or a read timeout and a total are specified, the shorter timeout will be applied. Defaults to None. :type total: integer, float, or None :param connect: The maximum amount of time (in seconds) to wait for a connection attempt to a server to succeed. Omitting the parameter will default the connect timeout to the system default, probably `the global default timeout in socket.py <http://hg.python.org/cpython/file/603b4d593758/Lib/socket.py#l535>`_. None will set an infinite timeout for connection attempts. :type connect: integer, float, or None :param read: The maximum amount of time (in seconds) to wait between consecutive read operations for a response from the server. Omitting the parameter will default the read timeout to the system default, probably `the global default timeout in socket.py <http://hg.python.org/cpython/file/603b4d593758/Lib/socket.py#l535>`_. None will set an infinite timeout. :type read: integer, float, or None .. note:: Many factors can affect the total amount of time for urllib3 to return an HTTP response. For example, Python's DNS resolver does not obey the timeout specified on the socket. Other factors that can affect total request time include high CPU load, high swap, the program running at a low priority level, or other behaviors. In addition, the read and total timeouts only measure the time between read operations on the socket connecting the client and the server, not the total amount of time for the request to return a complete response. For most requests, the timeout is raised because the server has not sent the first byte in the specified time. This is not always the case; if a server streams one byte every fifteen seconds, a timeout of 20 seconds will not trigger, even though the request will take several minutes to complete. If your goal is to cut off any request after a set amount of wall clock time, consider having a second "watcher" thread to cut off a slow request. """ #: A sentinel object representing the default timeout value DEFAULT_TIMEOUT = _GLOBAL_DEFAULT_TIMEOUT def __init__(self, total=None, connect=_Default, read=_Default): self._connect = self._validate_timeout(connect, "connect") self._read = self._validate_timeout(read, "read") self.total = self._validate_timeout(total, "total") self._start_connect = None def __str__(self): return "%s(connect=%r, read=%r, total=%r)" % ( type(self).__name__, self._connect, self._read, self.total, ) @classmethod def _validate_timeout(cls, value, name): """ Check that a timeout attribute is valid. :param value: The timeout value to validate :param name: The name of the timeout attribute to validate. This is used to specify in error messages. :return: The validated and casted version of the given value. :raises ValueError: If it is a numeric value less than or equal to zero, or the type is not an integer, float, or None. """ if value is _Default: return cls.DEFAULT_TIMEOUT if value is None or value is cls.DEFAULT_TIMEOUT: return value if isinstance(value, bool): raise ValueError( "Timeout cannot be a boolean value. It must " "be an int, float or None." ) try: float(value) except (TypeError, ValueError): raise ValueError( "Timeout value %s was %s, but it must be an " "int, float or None." % (name, value) ) try: if value <= 0: raise ValueError( "Attempted to set %s timeout to %s, but the " "timeout cannot be set to a value less " "than or equal to 0." % (name, value) ) except TypeError: # Python 3 raise ValueError( "Timeout value %s was %s, but it must be an " "int, float or None." % (name, value) ) return value @classmethod def from_float(cls, timeout): """ Create a new Timeout from a legacy timeout value. The timeout value used by httplib.py sets the same timeout on the connect(), and recv() socket requests. This creates a :class:`Timeout` object that sets the individual timeouts to the ``timeout`` value passed to this function. :param timeout: The legacy timeout value. :type timeout: integer, float, sentinel default object, or None :return: Timeout object :rtype: :class:`Timeout` """ return Timeout(read=timeout, connect=timeout) def clone(self): """ Create a copy of the timeout object Timeout properties are stored per-pool but each request needs a fresh Timeout object to ensure each one has its own start/stop configured. :return: a copy of the timeout object :rtype: :class:`Timeout` """ # We can't use copy.deepcopy because that will also create a new object # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to # detect the user default. return Timeout(connect=self._connect, read=self._read, total=self.total) def start_connect(self): """ Start the timeout clock, used during a connect() attempt :raises urllib3.exceptions.TimeoutStateError: if you attempt to start a timer that has been started already. """ if self._start_connect is not None: raise TimeoutStateError("Timeout timer has already been started.") self._start_connect = current_time() return self._start_connect def get_connect_duration(self): """ Gets the time elapsed since the call to :meth:`start_connect`. :return: Elapsed time in seconds. :rtype: float :raises urllib3.exceptions.TimeoutStateError: if you attempt to get duration for a timer that hasn't been started. """ if self._start_connect is None: raise TimeoutStateError( "Can't get connect duration for timer that has not started." ) return current_time() - self._start_connect @property def connect_timeout(self): """ Get the value to use when setting a connection timeout. This will be a positive float or integer, the value None (never timeout), or the default system timeout. :return: Connect timeout. :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None """ if self.total is None: return self._connect if self._connect is None or self._connect is self.DEFAULT_TIMEOUT: return self.total return min(self._connect, self.total) @property def read_timeout(self): """ Get the value for the read timeout. This assumes some time has elapsed in the connection timeout and computes the read timeout appropriately. If self.total is set, the read timeout is dependent on the amount of time taken by the connect timeout. If the connection time has not been established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be raised. :return: Value to use for the read timeout. :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect` has not yet been called on this object. """ if ( self.total is not None and self.total is not self.DEFAULT_TIMEOUT and self._read is not None and self._read is not self.DEFAULT_TIMEOUT ): # In case the connect timeout has not yet been established. if self._start_connect is None: return self._read return max(0, min(self.total - self.get_connect_duration(), self._read)) elif self.total is not None and self.total is not self.DEFAULT_TIMEOUT: return max(0, self.total - self.get_connect_duration()) else: return self._read


Search
Origin:
Destination:
search
Favourite
Beep
{{beep.first_stop.name}}
{{beep.display_informations.commercial_mode}}
direction {{beep.display_informations.direction}}
No alert yet


| Template::_build_nodes |
( |
|
$s | ) |
|
|
private |
| Template::_get_var |
( |
|
$name, |
|
|
|
$retNoKey = false |
|
) |
| |
|
private |
| Template::_preg_error |
( |
| ) |
|
|
private |
| Template::_push_stack |
( |
| ) |
|
|
private |
| Template::_replcb_debug |
( |
|
$args | ) |
|
|
private |
DEBUG node
{{ debug $var [$var [$var [...]]] }}{{ enddebug }}
replace node with
var_dump($var, $var, ...);
| Template::_replcb_for |
( |
|
$args | ) |
|
|
private |
FOR node
{{ for < $var>=""> as $name }}...{{ endfor }} {{ for < $var>=""> as $key=>$name }}...{{ endfor }}
| Template::_replcb_if |
( |
|
$args | ) |
|
|
private |
IF node
{{ if < $var>=""> }}...[{{ else }} ...] {{ endif }} {{ if < $var>="">==<val|$var> }}...[{{ else }} ...]{{ endif }} {{ if < $var>="">!=<val|$var> }}...[{{ else }} ...]{{ endif }}
| Template::_replcb_inc |
( |
|
$args | ) |
|
|
private |
INC node
{{ inc <templatefile> [with $var1=$var2] }}{{ endinc }}
| Template::_replcb_node |
( |
|
$m | ) |
|
|
private |
| Template::get_markup_template |
( |
|
$file, |
|
|
|
$root = '' |
|
) |
| |
| Template::replace |
( |
|
$s, |
|
|
|
$r |
|
) |
| |
|
private |
| Template::replace_macros |
( |
|
$s, |
|
|
|
$r |
|
) |
| |
| Template::var_replace |
( |
|
$s | ) |
|
|
private |
regexp: $ literal $ ([)? optional open square bracket ([a-zA-Z0-9-_]+.?)+ var name, followed by optional dot, repeated at least 1 time (?(1)]) if there was opened square bracket (subgrup 1), match close bracket
Referenced by replace_macros().
| Template::$name ="internal" |
|
static |
| Template::$nodes = array() |
| Template::$stack = array() |
The documentation for this class was generated from the following file:


--- layout: post title: "Analyzing Inverse Problems in Natural Science using Invertible Neural Networks" subtitle: "Ullrich Koethe, HCI" date: 2019-11-20 19:00:0 +0000 background: '/img/posts/koethe_background.jpg' future_date: False layer_shift: True ---
Uncertainty quantification is a hot topic in neural network research. This talk will focus on inverse problems, where high uncertainty arises from the inherent ambiguities of ill-posed inverse processes. This type of problem is ubiquitous in natural sciences, and existing approaches are either very expensive or suffer from drastic approximations. The talk presents a new class of invertible neural networks that generalize established Bayesian approaches from the linear to the non-linear setting. These networks work equally well in the forward as well as the inverse direction and thus enable new training and approximation methods, which become asymptotically exact in the perfect convergence limit. A variety of promising results from medical imaging, computer vision, and environmental physics demonstrate the practical utility of the new method.
Prof. Ullrich Koethe is heading the newly founded group on “Explainable Machine Learning” at the Visual Learning Lab Heidelberg. He is interested in the connection between machine learning and its applications in image analysis, medicine, and natural sciences. Explainable learning shall open-up the blackbox of successful learning algorithms, in particular neural networks, to provide insight rather than mere numbers. In addition, he is interested in generic software bringing state-of-the-art algorithms to the end user and maintain the VIGRA image analysis library.
The event will take place on Wednesday, 20 November, 2019 at 7:00pm at the DKFZ Communication Center (K1+K2), Im Neuenheimer Feld 280. Drinks and snacks will be provided, courtesy of the Division of Medical Image Computing at DKFZ. Kindly help us plan ahead by registering for the event on our meetup page.


Class rex_effect_mediapath
- rex_effect_abstract
- rex_effect_mediapath
Package: redaxo\media-manager
Located at redaxo/src/addons/media_manager/lib/effects/effect_mediapath.php
Located at redaxo/src/addons/media_manager/lib/effects/effect_mediapath.php
Methods summary
public
|
||
public
|
||
public
|
||
public
|
Methods inherited from rex_effect_abstract
keepTransparent()
,
setMedia()
,
setParams()


After working with Ruby for a short time and being introduced to JavaScript this past week, it's interesting to see the similarities between the two languages. It's funny to me that the smallest difference in syntax, including or not including a ";", can be the hardest part to get used to.
In JavaScript and Ruby creating functions and methods respectively are very similar, but do have slightly different syntax:
Here's the JavaScript function:
And here's the Ruby method:
*Both images taken from here*
As you can see in the images above, JavaScript looks to have a much more strict syntax with the inclusion of the curly braces "{}" and the semi-colons ";". I like the fact that Ruby is more forgiving in this syntax and it is assumed for you when writing your code.
The next comparison of the semi-colon can be seen here when comparing syntax for iterations through arrays:
And again, images taken from here
So to reiterate, I feel like Ruby is a much more forgiving language syntactically. I know that something as simple as including a ";" seems silly to forget, but it can definitely cause your programs not to function properly.


metacell.dynamake package¶
Submodules¶
metacell.dynamake.analysis module¶
Build steps for analyzing metacell data.
metacell.dynamake.common module¶
Common functions for DynaMake steps.
-
async
metacell.dynamake.common.
call
(name: Optional[str] = None, *, with_config: bool = False, with_parallel: bool = False, with_intermediate: bool = False, log_context: Optional[str] = None, **kwargs) → None¶ Invoke the
metacell_call
script to invoke some top-level Python function.If the called function name is not specified, it is assumed to be identical to the current step name.
If
with_config
isTrue
, then a--config
parameter is added usingdynamake.application.with_config()
.If
with_parallel
isTrue
, then--jobs
is added with a value computed by :py:func:tgutils.make.parallel_jobs, that is, taking into account the innermost :py:func:tgutils.make.tg_require.If
with_intermediate
isTrue
, then the program uses thewrite_intermediate
parameter.The first named argument is special; it is automatically emphasized, and also passed to the
--log_context
command line option. You can disable this by providing an explicitlog_context
(which may be empty).
-
async
metacell.dynamake.common.
ecall
(name: Optional[str] = None, *, with_config: bool = False, with_parallel: bool = False, with_intermediate: bool = False, log_context: Optional[str] = None, **kwargs) → None¶ Similar to
call
but firste
-xpand all the named arguments.
-
metacell.dynamake.common.
erequire_ancestor
(nested_path: str) → str¶ Require a file which may exist in a parent directory.
Searches for the file in the nested directory, and failing that, in its parent(s), up to and including the current directory (but no further).
metacell.dynamake.group module¶
[:,np.newaxis] Build steps for grouping cells to metacells.
-
async
metacell.dynamake.group.
group_few_profiles
(profiles_dir: str) → None¶
-
async
metacell.dynamake.group.
group_many_profiles
(profiles_dir: str) → None¶
metacell.dynamake.importation module¶
Build steps for importing raw data into the metacell pipeline.
-
async
metacell.dynamake.importation.
convert_10x
() → None¶
-
async
metacell.dynamake.importation.
convert_hca
() → None¶
-
async
metacell.dynamake.importation.
convert_moca
() → None¶
-
metacell.dynamake.importation.
standard_format_file
(name: str) → str¶
metacell.dynamake.view module¶
Build steps for creating views of the data to analyze.
Module contents¶
DynaMake rules for the metacell work flow.


This document validates as CSS level 3 !
To show your readers that you've taken the care to create an interoperable Web page, you may display this icon on any page that validates. Here is the XHTML you could use to add this icon to your Web page:

(close the img tag with > instead of /> if using HTML <= 4.01)
If you like, you can download a copy of this image to keep in your local web directory, and change the XHTML fragment above to reference your local image rather than the one on this server.
If you would like to create a link to this page (i.e., this validation result) to make it easier to re-validate this page in the future or to allow others to validate your page, the URI is:
http://jigsaw.w3.org/css-validator/validator$link or http://jigsaw.w3.org/css-validator/check/referer (for HTML/XML document only)
(Or, you can just add the current page to your bookmarks or hotlist.)


Ploror688.github.io
Comprehensive textbooks, digital products, teaching materials and services for Early Childhood, Elementary, Middle School, High School and Professional. Woodlands Junior-rivers Homework Help, Help With Academic. Get a 10th grade online tutor, download free worksheets, test prep and homework help in Math, Science and English from eTutorWorld. Affordable, convenient certified. Online homework and grading tools for instructors and students that reinforce student learning through practice and instant feedback.
Tenth grade Chemistry Lessonplans, homework, quizzes.
Amazon.com: Principles of Anatomy and Physiology 14e Binder Ready Version + WileyPLUS Learning Space Registration Card<PHONE_NUMBER>126): Gerard J. Tortora, Bryan. Grade - English-Spanish Dictionary - WordReference.com. Top Hat’s student engagement software enhances the course experience by motivating students to learn, participate and ultimately master the content you teach. Chemistry: Steven S. Zumdahl, Susan A. Zumdahl, Donald. Answer Me True - I feminized my husband with estrogen. Find quality Lessons, lessonplans, and other resources for Tenth Grade Chemistry Buy Chemistry on Amazon.com FREE SHIPPING on qualified orders. Coming soon to the internet's top social site Facebook! Check back soon to follow us and connect with our community members. LATEST ACTIVITY.
Students Assignment Help provides Online Assignment writing and homework help services at affordable price with 100% unique content. Learn why the Common Core is important for your child. What parents should know; Myths vs. facts. Write My Essay Now! Urgent Essay Writing Service. Amazon.com: Principles of Anatomy and Physiology. Advanced math homework help - Help making thesis statement. Best Academic Help. Starting at $7.98 per page. Get DISCOUNT Now! Help With Academic Papers Online - Best in UK, Woodlands Junior-rivers Homework. Provides a complete web based educational environment for K-12 and Higher-Education mathematics, accounting, statistics, and chemistry.
Мы хотели бы показать здесь описание, но сайт, который вы просматриваете, этого не позволяет. 10TH GRADE HOMEWORK PORTAL. Chemistry Regents Chemistry is International Leadership Charter High School 3030 Riverdale Avenue, Bronx, NY 10463 Office:. Write my essay in time! Order papers from our professional team that offers paper writing on any type of topic. Fast, cheap and unique. Such services are helpful in improving the quality of content and ensuring you get a passing grade. the help with homework in math your physics, chemistry. Break through to improving results with Pearson's MyLab Mastering. We're working with educators and institutions to improve results for students everywhere.
This lesson defines reactants within chemical reactions and how reactants are written in chemical reactions. The role of chemical reactions. Turnitin provides instructors with the tools to prevent plagiarism, engage students in the writing process, and provide personalized feedback. One-Hundred-and-Twenty-Sixth Annual Undergraduate Bulletin. 10th Grade English: Homework Help Resource - Study.com. Assignment Help services Online Homework help Custom. Grade 10 chemistry homework help?? (its just one question)? the two metals , sodim Can someone help me with my 10th grade chemistry homework.
10th grade worksheets; . Home Online Science Tutoring 11th Grade Chemistry. . Online High School Chemistry Help makes the definitions and theories
10TH GRADE HOMEWORK PORTAL ILCHS International. Delegation strategies for the NCLEX, Prioritization for the NCLEX, Infection Control for the NCLEX, FREE resources for the NCLEX, FREE NCLEX Quizzes for the NCLEX. Home Common Core State Standards Initiative. Do your homework service : 10th grade chemistry homework. One-Hundred-and-Twenty-Sixth Annual Undergraduate Bulletin 2017–18 The Undergraduate Bulletin is also available on the Web at uncg.edu.
NCERT Solutions for Class 9: Ch 1 The Fun they Had Beehive English. ALEKS -- Assessment and Learning, K-12, Higher Education. 10th Grade Online Tutor - Test prep help eTutorWorld. Grade - Translation to Spanish, pronunciation, and forum discussions. Advanced math homework help . but now I can do 6th grade math now because of MathHelp.com.” Maria “I was just telling my parents I needed 6th grade Reactant in Chemistry: Definition Examples - Video. Comprehensive NCLEX Questions Most Like The NCLEX.
Search using a saved search preference or by selecting one or more content areas and grade levels to view standards, related Eligible Content, assessments
AP Central – Education Professionals – The College Board. 11th Grade Chemistry eTutorWorld. 10th Grade Chemistry How light Is Created and Spectra. Course materials, exam information, and professional development opportunities for AP teachers and coordinators. Help your 10th grader get through a tough homework assignment or prepare for a test with this English homework help course. Our short, fun video.


The Mosaic web browser was released in 1993. As the first browser with a graphical user interface accessible to non-technical people, it played a prominent role in the rapid growth of the nascent World Wide Web. The lead developers of Mosaic then founded the Netscape corporation, which released a more polished browser, Netscape Navigator, in 1994. Navigator quickly became the most used browser.
During these formative years of the Web, web pages could only be static, lacking the capability for dynamic behavior after the page was loaded in the browser. There was a desire in the burgeoning web development scene to remove this limitation, so in 1995, Netscape decided to add a scripting language to Navigator. They pursued two routes to achieve this: collaborating with Sun Microsystems to embed the Java programming language, while also hiring Brendan Eich to embed the Scheme language.
Netscape management soon decided that the best option was for Eich to devise a new language, with syntax similar to Java and less like Scheme or other extant scripting languages. Although the new language and its interpreter implementation were officially called LiveScript when first shipped as part of a Navigator release in September 1995, the name was changed to JavaScript three months later.
The choice of the JavaScript name has caused confusion, sometimes giving the impression that it is a spin-off of Java. Since Java was the hot new programming language at the time, this has been characterized as a marketing ploy by Netscape to give its own new language cachet.
Source: Wikipedia. Text is available under the Creative Commons Attribution-ShareAlike License. Wikipedia ℗ is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization.


|
MatrixBerryCore
|
Namespaces | |
| test | |
| xls | |
Classes | |
| class | PathUtils |
| class | TmpDataManager |
| TMPDATAMANAGER implements a basic functionality for managing temporary data folders. More... | |
Functions | |
| function | copyfile (in srcName, in dstName) |
| COPYFILE is a simplified version of the built-in function that supports long file paths on Windows (>260 symbols). Only copying of a single file to a destination folder/file is supported. More... | |
| function | isdir (in dirName, in isJavaBased) |
| ISDIR returns true if a specified name corresponds to an existing directory. More... | |
| function | isfile (in fileName, in isJavaBased) |
| ISFILE returns true if a specified name corresponds to an existing file. More... | |
| function | listdirsrecursive (in dirName, in patternStr, in maxDepth) |
| LISTDIRSRECURSIVE returns a list of directories with names matching a specified pattern in all the subdirectories of a directory up to the specified depth. More... | |
| function | listfilesrecursive (in dirName, in patternStr, in maxDepth) |
| LISTFILESRECURSIVE returns a list of files with names matching a specified pattern in all the subdirectories of a directory up to the specified depth. More... | |
| function | mkdir (in dirName) |
| MKDIR creates a directory recursively. More... | |
| function | rmdir (in dirName, in sFlag) |
| RMDIR removes a directory (optionally recursively) More... | |
| function mxberry::io::copyfile | ( | in | srcName, |
| in | dstName | ||
| ) |
COPYFILE is a simplified version of the built-in function that supports long file paths on Windows (>260 symbols). Only copying of a single file to a destination folder/file is supported.
* Input: * regular: * srcName: char[1,] - source file name * dstName: char[1,] - destination file/directory name * * Output: * isSuccess: logical[1,1] - if true, execution was successful * msgStr: char[1,] - string containing the warning or error message * if operation is unsuccessful, empty otherwise * messageId: char[1,] - string containing the warning or error message id * if operation is unsuccessful, empty otherwise * * Note: as opposed to the built-in copyfile function this function doesn't * support wildcards and copying multiple files *
| function mxberry::io::isdir | ( | in | dirName, |
| in | isJavaBased | ||
| ) |
ISDIR returns true if a specified name corresponds to an existing directory.
* Input: * regular: * dirName: char[1,] - directory name to check * * optional: * isJavaBased: logical[1,1] - if true (default), Java-based * implementation is used and Matlab implementation - otherwise. * Output: * isPositive: logical[1,1] - true if the directory exists *
| function mxberry::io::isfile | ( | in | fileName, |
| in | isJavaBased | ||
| ) |
ISFILE returns true if a specified name corresponds to an existing file.
* Input: * regular: * fileName: char[1,] - file name to check * * optional: * isJavaBased: logical[1,1] - if true (default), Java-based * implementation is used and Matlab implementation - otherwise. * Output: * isPositive: logical[1,1] - true if the file exists *
| function mxberry::io::listdirsrecursive | ( | in | dirName, |
| in | patternStr, | ||
| in | maxDepth | ||
| ) |
LISTDIRSRECURSIVE returns a list of directories with names matching a specified pattern in all the subdirectories of a directory up to the specified depth.
* Input: * regular: * dirName: char[1,] - directory name to scan * * patternStr: char[1,] - either Glob expression with "glob:" prefix * ("glob:**.m" for instance) or Regex expression with "regex:" * prefix. * -------Glob syntax description-------- * *.txt Matches all files that has extension as txt. * *.{html,htm} Matches all files that has extension as * html or htm. { } are used to group patterns and , * comma is used to separate patterns. * ?.txt Matches all files that has any single charcter as * name and extension as txt. * *.* Matches all files that has . in its name. * C:\\Users\\* Matches any files in C: "Users" directory * in Windows file system. Backslash is used to escape a * special character. * /home/** Matches /home/foo and /home/foo/bar on UNIX * platforms. ** matches strings of characters corssing * directory boundaries. * [xyz].txt Matches a file name with single character "x" * or "y" or "z" and extension as txt. Square brackets [ ] * are used to sepcify a character set. * [a-c].txt Matches a file name with single character "a" or * "b" or "c" and extension as txt. Hypehen ÿ is used to * specify a range and used in [ ] * [!a].txt Matches a file name with single character that * is not "a". ! is used for negation. * * maxDepth: double[1,1] - maximum depth, use Inf means for no depth * liminations * Output: * dirNameList: cell[nFiles,1] of char[1,] - resuling list of directories *
| function mxberry::io::listfilesrecursive | ( | in | dirName, |
| in | patternStr, | ||
| in | maxDepth | ||
| ) |
LISTFILESRECURSIVE returns a list of files with names matching a specified pattern in all the subdirectories of a directory up to the specified depth.
* Input: * regular: * dirName: char[1,] - directory name to scan * * patternStr: char[1,] - either Glob expression with "glob:" prefix * ("glob:**.m" for instance) or Regex expression with "regex:" * prefix. * -------Glob syntax description-------- * *.txt Matches all files that has extension as txt. * *.{html,htm} Matches all files that has extension as * html or htm. { } are used to group patterns and , * comma is used to separate patterns. * ?.txt Matches all files that has any single charcter as * name and extension as txt. * *.* Matches all files that has . in its name. * C:\\Users\\* Matches any files in C: "Users" directory * in Windows file system. Backslash is used to escape a * special character. * /home/** Matches /home/foo and /home/foo/bar on UNIX * platforms. ** matches strings of characters corssing * directory boundaries. * [xyz].txt Matches a file name with single character "x" * or "y" or "z" and extension as txt. Square brackets [ ] * are used to sepcify a character set. * [a-c].txt Matches a file name with single character "a" or * "b" or "c" and extension as txt. Hypehen ÿ is used to * specify a range and used in [ ] * [!a].txt Matches a file name with single character that * is not "a". ! is used for negation. * * maxDepth: double[1,1] - maximum depth, use Inf means for no depth * liminations * Output: * fileNameList: cell[nFiles,1] of char[1,] - resuling list of files *
| function mxberry::io::mkdir | ( | in | dirName | ) |
MKDIR creates a directory recursively.
* Input: * regular: * dirName: char[1,] directory name * * Output: * isSuccess: logical[1,1] - if true, execution was successful * msgStr: char[1,] - string containing the warning or error message * if operation is unsuccessful, empty otherwise * messageId: char[1,] - string containing the warning or error message id * if operation is unsuccessful, empty otherwise * * Note: tha main difference from the built-in mkdir function is that this * function works with long file names on Windows *
| function mxberry::io::rmdir | ( | in | dirName, |
| in | sFlag | ||
| ) |
RMDIR removes a directory (optionally recursively)
* Input: * regular: * dirName: char[1,] directory name * optional: * sFlag: char[1,1] - can only take 's' value, if sFlag is specified * the directory is removed with all subfolders and files. If the * flag is not specified the function expects an empty directory * * Output: * isSuccess: logical[1,1] - if true, execution was successful * msgStr: char[1,] - string containing the warning or error message * if operation is unsuccessful, empty otherwise * messageId: char[1,] - string containing the warning or error message id * if operation is unsuccessful, empty otherwise * * Note: tha main difference from the built-in rmdir function is that this * function works with long file names on Windows *


--- layout: post permalink: esalerugs.html Tags: Array NameOfCoupon: ESaleRugs Cash Back Summary: See our ESaleRugs Coupon Code, ESaleRugs Rebate, ESaleRugs Promo Code, ESaleRugs Discount, ESaleRugs Coupon Cash Back Rebate here. MetaKeywords: ESaleRugs Coupon Code, ESaleRugs Rebate, ESaleRugs Promo Code, ESaleRugs Cash Back Rebate, ESaleRugs Discount, ESaleRugs Coupon Image: images/20451.jpg LinkURL: http://www.shareasale.com/r.cfm?b=156201&u=412002&m=20451 affiliate_url_link: http://www.icouponblog.com/jane.php?id=63 thesis_readmore: See the ESaleRugs Coupon thesis_thumb: http://www.icouponblog.com/tn.php?merchantURL=esalerugs.com Title: Save 5% - ESaleRugs Coupon Code for esalerugs.com. ESaleRugs Rebate & Discount thesis_description: Our ESaleRugs Discount Coupon Code for esalerugs.com. We have the best ESaleRugs Rebate anywhere. thesis_keywords: ESaleRugs, ESaleRugs Coupon Code, ESaleRugs Discount, ESaleRugs Rebate product_name: ESaleRugs hop_url: http://www.icouponblog.com/hop.php?id=63 ---
Does that ratty old area rug make your sophisticated living room look like a motel lobby? A new rug is a great way to instantly change and update the look of any room. Whether it's your living room, bedroom or foyer, ESaleRugs has the perfect rugs for every space. Maybe you prefer traditional styles and warm earthy tones. Or perhaps your contemporary outlook requires bold color palettes and abstract designs. No matter what your style of taste, ESaleRugs rugs will spread themselves at your feet.
ESaleRugs offers a huge selection of rugs. You'll never have to go to different stores or websites looking for the perfect rug. From Oriental to Persian, conservative to contemporary, ESaleRugs will be you one-stop shop to all rugs. The ESaleRugs Rebate will give you a boost towards great savings on your ESaleRugs rugs. Their BBB Accreditation will show you that they're the safe and secure way to shop.
So go ahead. Treat yourself to the lavish and luxurious rugs that ESaleRugs offers. And use the ESaleRugs Coupon and Rebate to save on your favorite choices. Just click on the ESaleRugs Coupon above and start saving today. You’ll be glad you did!


This filter includes/excludes jobs based on whether they have selected the
"Enable project-based security" option.
Options
- Match type:
-
Whether to add or remove jobs from this view. There's two kinds of match types:
- Include matched/unmatched: adds additional jobs to this view.
- Exclude matched/unmatched: removes jobs from this view that have been included by previous filters.
Note
This filter does not provide security - it merely provides convenient views
that feed off of the security you've already set up.


@ThreadSafe
public interface MongoDatabase
Note: Additions to this interface will not be considered to break binary compatibility.
| Modifier and Type | Method and Description |
|---|---|
rx.Observable<Success> |
createCollection(String collectionName)
Create a new collection with the given name.
|
rx.Observable<Success> |
createCollection(String collectionName,
com.mongodb.client.model.CreateCollectionOptions options)
Create a new collection with the selected options
|
rx.Observable<Success> |
createView(String viewName,
String viewOn,
List<? extends org.bson.conversions.Bson> pipeline)
Creates a view with the given name, backing collection/view name, and aggregation pipeline that defines the view.
|
rx.Observable<Success> |
createView(String viewName,
String viewOn,
List<? extends org.bson.conversions.Bson> pipeline,
com.mongodb.client.model.CreateViewOptions createViewOptions)
Creates a view with the given name, backing collection/view name, aggregation pipeline, and options that defines the view.
|
rx.Observable<Success> |
drop()
Drops this database.
|
org.bson.codecs.configuration.CodecRegistry |
getCodecRegistry()
Get the codec registry for the MongoDatabase.
|
MongoCollection<org.bson.Document> |
getCollection(String collectionName)
Gets a collection.
|
<TDocument> |
getCollection(String collectionName,
Class<TDocument> clazz)
Gets a collection, with a specific default document class.
|
String |
getName()
Gets the name of the database.
|
ObservableAdapter |
getObservableAdapter()
Get the ObservableAdapter for the MongoDatabase.
|
com.mongodb.ReadConcern |
getReadConcern()
Get the read concern for the MongoDatabase.
|
com.mongodb.ReadPreference |
getReadPreference()
Get the read preference for the MongoDatabase.
|
com.mongodb.WriteConcern |
getWriteConcern()
Get the write concern for the MongoDatabase.
|
rx.Observable<String> |
listCollectionNames()
Gets the names of all the collections in this database.
|
ListCollectionsObservable<org.bson.Document> |
listCollections()
Finds all the collections in this database.
|
<TResult> ListCollectionsObservable<TResult> |
listCollections(Class<TResult> clazz)
Finds all the collections in this database.
|
rx.Observable<org.bson.Document> |
runCommand(org.bson.conversions.Bson command)
Executes command in the context of the current database.
|
<TResult> rx.Observable<TResult> |
runCommand(org.bson.conversions.Bson command,
Class<TResult> clazz)
Executes command in the context of the current database.
|
rx.Observable<org.bson.Document> |
runCommand(org.bson.conversions.Bson command,
com.mongodb.ReadPreference readPreference)
Executes command in the context of the current database.
|
<TResult> rx.Observable<TResult> |
runCommand(org.bson.conversions.Bson command,
com.mongodb.ReadPreference readPreference,
Class<TResult> clazz)
Executes command in the context of the current database.
|
MongoDatabase |
withCodecRegistry(org.bson.codecs.configuration.CodecRegistry codecRegistry)
Create a new MongoDatabase instance with a different codec registry.
|
MongoDatabase |
withObservableAdapter(ObservableAdapter observableAdapter)
Create a new MongoDatabase instance with a different
ObservableAdapter . |
MongoDatabase |
withReadConcern(com.mongodb.ReadConcern readConcern)
Create a new MongoDatabase instance with a different read concern.
|
MongoDatabase |
withReadPreference(com.mongodb.ReadPreference readPreference)
Create a new MongoDatabase instance with a different read preference.
|
MongoDatabase |
withWriteConcern(com.mongodb.WriteConcern writeConcern)
Create a new MongoDatabase instance with a different write concern.
|
String getName()
ObservableAdapter getObservableAdapter()
ObservableAdapter
org.bson.codecs.configuration.CodecRegistry getCodecRegistry()
CodecRegistry
com.mongodb.ReadPreference getReadPreference()
ReadPreference
com.mongodb.WriteConcern getWriteConcern()
WriteConcern
com.mongodb.ReadConcern getReadConcern()
ReadConcern
MongoDatabase withObservableAdapter(ObservableAdapter observableAdapter)
ObservableAdapter
.observableAdapter
- the new ObservableAdapter
for the databaseMongoDatabase withCodecRegistry(org.bson.codecs.configuration.CodecRegistry codecRegistry)
codecRegistry
- the new CodecRegistry
for the databaseMongoDatabase withReadPreference(com.mongodb.ReadPreference readPreference)
readPreference
- the new ReadPreference
for the databaseMongoDatabase withWriteConcern(com.mongodb.WriteConcern writeConcern)
writeConcern
- the new WriteConcern
for the databaseMongoDatabase withReadConcern(com.mongodb.ReadConcern readConcern)
readConcern
- the new ReadConcern
for the databaseMongoCollection<org.bson.Document> getCollection(String collectionName)
collectionName
- the name of the collection to return<TDocument> MongoCollection<TDocument> getCollection(String collectionName, Class<TDocument> clazz)
TDocument
- the type of the class to use instead of Document
.collectionName
- the name of the collection to returnclazz
- the default class to cast any documents returned from the database into.rx.Observable<org.bson.Document> runCommand(org.bson.conversions.Bson command)
command
- the command to be runrx.Observable<org.bson.Document> runCommand(org.bson.conversions.Bson command, com.mongodb.ReadPreference readPreference)
command
- the command to be runreadPreference
- the ReadPreference
to be used when executing the command<TResult> rx.Observable<TResult> runCommand(org.bson.conversions.Bson command, Class<TResult> clazz)
TResult
- the type of the class to use instead of Document
.command
- the command to be runclazz
- the default class to cast any documents returned from the database into.<TResult> rx.Observable<TResult> runCommand(org.bson.conversions.Bson command, com.mongodb.ReadPreference readPreference, Class<TResult> clazz)
TResult
- the type of the class to use instead of Document
.command
- the command to be runreadPreference
- the ReadPreference
to be used when executing the commandclazz
- the default class to cast any documents returned from the database into.rx.Observable<Success> drop()
rx.Observable<String> listCollectionNames()
ListCollectionsObservable<org.bson.Document> listCollections()
<TResult> ListCollectionsObservable<TResult> listCollections(Class<TResult> clazz)
TResult
- the target document type of the iterable.clazz
- the class to decode each document intorx.Observable<Success> createCollection(String collectionName)
collectionName
- the name for the new collection to createrx.Observable<Success> createCollection(String collectionName, com.mongodb.client.model.CreateCollectionOptions options)
collectionName
- the name for the new collection to createoptions
- various options for creating the collectionrx.Observable<Success> createView(String viewName, String viewOn, List<? extends org.bson.conversions.Bson> pipeline)
viewName
- the name of the view to createviewOn
- the backing collection/view for the viewpipeline
- the pipeline that defines the viewrx.Observable<Success> createView(String viewName, String viewOn, List<? extends org.bson.conversions.Bson> pipeline, com.mongodb.client.model.CreateViewOptions createViewOptions)
viewName
- the name of the view to createviewOn
- the backing collection/view for the viewpipeline
- the pipeline that defines the viewcreateViewOptions
- various options for creating the view


You can think of HTML like the physical construct of walls, floors, windows, doors which make up the structural component of your home and you can think of CSS as the decoration and presentation of your house so that includes the paint[outside, inside], carpet[colour, texture], how tall the roof from the ground is, hallway width, frame widths and so fourth. It allows us to structure and present our product however we may please with HTML being the structure and CSS being the presentation aspect.
Control flow is the chronological order in which things occur, let's say you have a routine where you brush your teeth, then you floss, then you mouthwash and rinse. These are the steps for basic dental hygiene and the order in which it occurred is what control flow is.
Loops is just what it sounds like, repetitive, looping and doing something over and over again.  We are just doing something x amount of times until a condition is met, which in this case is when you’ve completed writing the word 100 times and the loop exits.
The DOM is a data representation of the elements in a given document, it represents the structure and content as objects. We can think of it in a tree structure (DOM Tree) and each element in that tree or leaf is called a node. We can use these nodes to access certain properties and capabilities, we use javascript to access them and use them to do cool things.
With arrays we use indexing to access elements inside of an array and the square bracket notation.
let array = [0, 1, 2, 3, 4, 5]
array[1] // returns the second element in the array since we always start with 0 when counting in javascript
Objects we use the object name and then we specify using the dot or bracket notation the property in which we would like to access:
let user = {
name: “John”,
age: 23
}
user.name // this returns John and we are using the dot notation
user[“name”] // this returns John too but we are using bracket notation instead which is similar to arrays but instead we reference names
Functions are just a task which we predefined once and we can call this predefined code as many times as we need. It allows us to reuse code instead of repeating ourselves over and over making our code cluttered.


Graphland with quantum computer
algorithm
sampler
simulated annealing
dwave
exact
graph
run
clear
''


| Author: | Riccardo Murri<EMAIL_ADDRESS>|
|---|---|
| Date: | 2010-10-06 |
| Revision: | $Revision$ |
These instructions show how to install VM-MAD from the source repository into a separate python environment (called virtualenv). Installation into a virtualenv has two distinct advantages:
- All code is confined in a single directory, and can thus be easily replaced/removed.
- Better dependency handling: additional Python packages that VM-MAD depends upon can be installed even if they conflict with system-level packages.
Install software prerequisites:
On Debian/Ubuntu, install packages: subversion, python-dev, python-profiler and the C/C++ compiler:
apt-get install subversion python-dev python-profiler gcc g++
On CentOS5, install packages subversion and python-devel and the C/C++ compiler:
yum install subversion python-devel gcc gcc-c++
On other Linux distributions, you will need to install:
Choose a directory where the VM-MAD software will be installed; any directory that’s writable by your Linux account will be ok.
If you are installing system-wide as root, we suggest you install VM-MAD into /opt/vm-mad.
If you are installing as a normal user, we suggest you install VM-MAD into $HOME/vm-mad.
If it’s not already installed, get the virtualenv Python package and install it:
wget http://pypi.python.org/packages/source/v/virtualenv/virtualenv-1.5.1.tar.gz
tar -xzf virtualenv-1.5.1.tar.gz && rm virtualenv-1.5.1.tar.gz
cd virtualenv-1.5.1/
If you are installing as `root`, the following command is all you
need:
python setup.py install
If instead you are installing as a normal, unprivileged user,
things get more complicated::
export PYTHONPATH=$HOME/lib64/python:$HOME/lib/python:$PYTHONPATH
export PATH=$PATH:$HOME/bin
mkdir -p $HOME/lib/python
python setup.py install --home $HOME
(You will also need to add the two `export` lines above to the
`$HOME/.bashrc` file -if using the `bash` shell- or to the
`$HOME/.cshrc` file -if using the `tcsh` shell.)
In any case, once `virtualenv`_ has been installed, you can exit
its directory and remove it::
cd ..
rm -rf virtualenv-1.5.1
Create a virtualenv to host the vm-mad installation at the directory you chose in Step 1.:
virtualenv $HOME/vm-mad # use '/opt/vm-mad' if installing as root
cd $HOME/vm-mad/
source bin/activate
Check-out the vm-mad files in a src/ directory:
svn co http://vm-mad.googlecode.com/svn/trunk src
Install the vm-mad in “develop” mode, so any modification pulled from subversion is immediately reflected in the running environment:
cd src/
env CC=gcc ./setup.py develop
cd .. # back into the `vm-mad` directory
This will place all the VM-MAD command into the vm-mad/bin/ directory.
These instructions show how to upgrade the VM-MAD scripts to the latest version found in the GC3 svn repository.
cd to the directory containing the VM-MAD virtualenv; assuming it’s named vm-mad as in the above installation instructions, you can issue the commands:
cd $HOME/vm-mad # use '/opt/vm-mad' if root
Activate the virtualenv
source bin/activate
Upgrade the vm-mad source and run the setup.py script again:
cd src
svn up
env CC=gcc ./setup.py develop
HTML documentation for the VMlib programming interface can be read online at:
You can also generate a local copy from the sources:
cd $HOME/vm-mad # use '/opt/vm-mad' if root
cd src/docs
make html
Note that you need the Python package Sphinx <http://sphinx.pocoo.org> (at least versdion 1.0) in order to build the documentation locally.


Best used in camera portrait mode
Loading
Here is a link to the site. Thank you for your time! See you on Tuesday!


hosted or on-premise
Getting started is as easy as...
git clone https://github.com/formio/formio.git cd formio npm install node server
Copyright © Form.io LLC 2019. All rights reserved
Renderer v


Every function with one output argument may have one or more
"inverse
" annotations to define inverses of this
function.
function f1 input A1 u1; ... input T1 uk; ... input Am um = am; ... input An un; output T2 y; annotation(inverse(uk = f2(..., y, ....), ui = f3(..., y, ...), ...)); algorithm ... end f1;
The meaning is that function "f2
" is one inverse to
function "f1
" where the previous output
"y
" is now an input and the previous input
"uk
" is now an output. More than one inverse can be
defined within the same inverse annotation. Several inverses are
separated by commas. (The inverse requires that for all valid
values of the input arguments of f2(...,y, ...)
and
uk
being calculated as uk := f2(..., y,
...)
implies the equality y = f1(..., uk, ...,)
up to a certain precision.)
Function "f1
" can have any number and types of
arguments with and without default value. The restriction is that
the number of unknown variables in the output argument of both
"f1
" and "f2
" must be the same and that
"f2
" must have exactly the same arguments as
"f1
" (with the same defaults, if an argument um has a
default), but the order of the arguments may be permuted.
function h_pTX input Real p "pressure"; input Real T "temperature"; input Real X[:] "mass fractions"; output Real h "specific enthalpy"; annotation(inverse(T = T_phX(p,h,X))); algorithm ... end h_pTX; function T_phX input Real p "pressure"; input Real h "specific enthalpy"; input Real X[:] "mass fractions"; output Real T "temperature"; algorithm ... end T_phX;


figo iOS SDK
This Framework wraps the figo Connect API endpoints in nicely typed Swift functions and types for your conveniece.
- We don’t support Swift versions older than 3.0
- Supports iOS and macOS
Client reference: docs/index.html
figo Connect API
The figo Connect API allows you to easily access your bank account including transaction history and submitting payments.
For a general introduction to figo and figo Connect please visit our main page.
Albeit figo offers an interface to submit wire transfers, payment processing is not our focus. Our main interest is bringing peoples bank accounts into applications allowing a more seamless and rich user experience.
API reference: http://docs.figo.io
Registering your application
Applications that would like to access the figo Connect have to register with us beforehand. If you would like to use figo Connect in your application, please email us. We would love to hear from you what you have in mind and will generate a client identifier and client secret for your application without any bureaucracy.
Website: http://figo.io
Setup
Submodule
To add figo as a git submodule run the following command:
git submodule add https://github.com/figome/ios-sdk.git
Integrate the framework into your project:
- Open the new folder and drag the Figo.xcodeproj into the Project Navigator of your application’s Xcode project.
- Select the Figo.xcodeproj in the Project Navigator and verify the deployment target matches that of your application target.
- Add the Figo.framework to your target(s) in the
Embedded Binaries
sections
The bridging header
We need CommonCrypto for our SSL pinning implementation, which is not available as a modular header. This makes it a bit challenging to import it into Swift. To work around this, we have included an Objective-C bridging header which imports the headers.
#import <CommonCrypto/CommonCrypto.h>
If you want to add our source files directly without adding the project as a sub-project in Xcode, you have to add that import to your bridging header.
Cocoapods / Carthage
We don’t support Cocoapods because it doesn’t support the bridging header at this time. As for Carthage, we just haven’t come around to it yet.
Usage
After creating an instance of FigoClient
you can call functions on it representing the API endpoints. These functions will always return a FigoResult<T>
, where T
will a corresponding type like Account
, [Account]
or [Transaction]
.
To use the client you need a client ID and a secret, see Registering your application for details.
import Figo
let figo = FigoClient(clientID: "xyz", clientSecret: "123")
Browse the client reference to see all available funtions or take a look at the test cases to see more examples of interaction with the API.
Create user
To be able to login and use the figo API a user is required. (Except for the Supported banks and services endpoints which don’t require to be logged in and therefore don’t require a user.)
let params = CreateUserParameters(name: "name", email: "email", password: "password", sendNewsletter: false, language: "de", affiliateUser: nil, affiliateClientID: nil)
figo.createNewFigoUser(params) { result in
...
}
Login
figo.loginWithUsername(username, password: password) { result in
self.refreshToken = result.value
...
}
The returned refresh token can be stored by the client for future logins, but only in a securely encryped store like the keychain or a SQLCipher database.
figo.loginWithRefreshToken(refreshToken) { result in
...
}
Retrieve all accounts
figo.retrieveAccounts() { result in
if let accounts = result.value {
for account in accounts {
...
}
}
}
Check for errors
figo.retrieveAccounts() { result in
switch result {
case .Success(let accounts):
print("Recieved \(accounts.count) accounts")
break
case .Failure(let error):
print(error.description)
break
}
}
Logging
For now we have a very simple logging solution. By default logging is disabled. If you want to enable logging, you can pass a logger instance to the FigoClient
.
let figo = FigoClient(clientID: "xyz", clientSecret: "123", logger: ConsoleLogger())
The ConsoleLogger
by default only logs debug and error events. If you want to see the request headers and responses, you can pass in the LogLevel
parameter.
let logger = ConsoleLogger(levels: [.verbose, .debug, .error])
let figo = FigoClient(clientID: "xyz", clientSecret: "123", logger: logger)
If you want full control of what is logged or how, you can provide your own instance that conforms to the Logger
protocol.
public protocol Logger {
var debug: (String) -> Void { get }
var verbose: (String) -> Void { get }
var error: (String) -> Void { get }
}
Endpoints
User
The central element of this API is the figo user, who owns bank accounts and grants selective access to them to other applications. This account can either be a free or a premium account. While both support the same set of features, the free account can only be used with the application through it got created, while a premium account can be used in all applications integrating figo.
createNewFigoUser(user: CreateUserParameters, _ completionHandler: (FigoResult<String>) -> Void)
retrieveCurrentUser(completionHandler: (FigoResult<User>) -> Void)
deleteCurrentUser(completionHandler: VoidCompletionHandler)
Authorization
The figo API uses OAuth 2 for authentication purposes and you need a user to login.
loginWithUsername(username: String, password: String, _ completionHandler: (FigoResult<String>) -> Void)
loginWithRefreshToken(refreshToken: String, _ completionHandler: VoidCompletionHandler)
revokeAccessToken(completionHandler: VoidCompletionHandler)
revokeRefreshToken(refreshToken: String, _ completionHandler: VoidCompletionHandler)
Accounts
Bank accounts are the central domain object of this API and the main anchor point for many of the other resources. This API does not only consider classical bank accounts as account, but also alternative banking services, e.g. credit cards or Paypal. The API does not distinguish between these two in most points.
retrieveAccounts(completionHandler: (FigoResult<[Account]>) -> Void)
retrieveAccount(accountID: String, _ completionHandler: (FigoResult<Account>) -> Void)
removeStoredPinFromBankContact(bankID: String, _ completionHandler: VoidCompletionHandler)
setupNewBankAccount(parameters: CreateAccountParameters, progressHandler: ProgressUpdate? = nil, _ completionHandler: VoidCompletionHandler)
Transactions
Each bank account has a list of transactions associated with it. The length of this list depends on the bank and time this account has been setup. In general the information provided for each transaction should be roughly similar to the contents of the printed or online transaction statement available from the respective bank. Please note that not all banks provide the same level of detail.
retrieveTransactions(parameters: RetrieveTransactionsParameters = RetrieveTransactionsParameters(), _ completionHandler: (FigoResult<TransactionListEnvelope>) -> Void)
retrieveTransactionsForAccount(accountID: String, parameters: RetrieveTransactionsParameters = RetrieveTransactionsParameters(), _ completionHandler: (FigoResult<TransactionListEnvelope>) -> Void)
retrieveTransaction(transactionID: String, _ completionHandler: (FigoResult<Transaction>) -> Void)
Synchronization
As banks commonly do not provide a push mechanism for distributing transaction updates, they need to be polled, which is called synchronization in this API. When triggering a synchronization please make sure that either the PIN for the bank contact is stored inside figo or that the user has the possibility to enter it.
Usually the bank accounts are synchronized on a daily basis. However, the synchronization can be triggered manually.
synchronize(parameters parameters: CreateSyncTaskParameters = CreateSyncTaskParameters(), progressHandler: ProgressUpdate? = nil, pinHandler: PinResponder, completionHandler: VoidCompletionHandler)
Supported banks and services
To set up a new bank account in figo, you need to provide the right kind of credentials for each bank. These settings can be retrieved from the API aswell as a list of all supported banks and bank-like services.
You don’t need to be logged in to use this group of endpoints.
retrieveSupportedBanks(countryCode: String? = nil, _ completionHandler: (FigoResult<[SupportedBank]>) -> Void)
retrieveSupportedServices(countryCode: String? = nil, _ completionHandler: (FigoResult<[SupportedService]>) -> Void)
retrieveLoginSettings(countryCode: String, bankCode: String, _ completionHandler: (FigoResult<LoginSettings>) -> Void)
Payments
In addition to retrieving information on a bank account, this API also provides the ability to submit wires in the name of the account owner.
Submitting a new payment generally is a two-phased process: 1. compile all information on the payment by creating and modifying a payment object 2. submitting that payment object to the bank.
While the first part is normal live interaction with this API, the second one uses the task processing system to allow for more time as bank servers are sometimes slow to respond. In addition you will need a TAN (Transaktionsnummer) from your bank to authenticate the submission.
retrievePaymentProposals(completionHandler: FigoResult<[PaymentProposal]> -> Void)
retrievePayments(completionHandler: FigoResult<[Payment]> -> Void)
retrievePaymentsForAccount(accountID: String, _ completionHandler: FigoResult<[Payment]> -> Void)
retrievePayment(paymentID: String, accountID: String, _ completionHandler: FigoResult<Payment> -> Void)
createPayment(parameters: CreatePaymentParameters, _ completionHandler: FigoResult<Payment> -> Void)
modifyPayment(payment: Payment, _ completionHandler: FigoResult<Payment> -> Void)
submitPayment(payment: Payment, tanSchemeID: String, pinHandler: PinResponder, challengeHandler: ChallengeResponder, _ completionHandler: VoidCompletionHandler)
Securities
Each depot account has a list of securities associated with it. In general the information provided for each security should be roughly similar to the contents of the printed or online depot listings available from the respective bank. Please note that not all banks provide the same level of detail.
retrieveSecurities(parameters: RetrieveSecuritiesParameters = RetrieveSecuritiesParameters(), _ completionHandler: (FigoResult<SecurityListEnvelope>) -> Void)
retrieveSecuritiesForAccount(accountID: String, parameters: RetrieveSecuritiesParameters = RetrieveSecuritiesParameters(), _ completionHandler: (FigoResult<SecurityListEnvelope>) -> Void)
retrieveSecurity(securityID: String, accountID: String, _ completionHandler: (FigoResult<Security>) -> Void)
Standing orders
Bank accounts can have standing orders associated with it if supported by the respective bank. In general the information provided for each standing order should be roughly similar to the content of the printed or online standing order statement available from the respective bank. Please note that not all banks provide the same level of detail.
retrieveStandingOrders(completionHandler: (FigoResult<[StandingOrder]>) -> Void)
retrieveStandingOrdersForAccount(accountID: String, _ completionHandler: (FigoResult<[StandingOrder]>) -> Void)
retrieveStandingOrder(standingOrderID: String, _ completionHandler: (FigoResult<StandingOrder>) -> Void)
Credits
The Figo Framework uses the following 3rd-party utilities:
- JohnSundell/Unbox for unboxing of JSON responses


MSG_GEN_INTERACTION_TEST_INPUT_RESTRICTABILITY
By default, GIV_DIALOG GenInteractions appear as non-modal windows. You may specify a dialog Interaction to appear as modal by setting either the GIA_MODAL attribute in the
GII_attrs
instance data field or by adding
HINT_INTERACTION_MODAL
in the object's vardata. When a modal dialog is displayed, input to all other parts of the application will be ignored until the dialog is dismissed. In OSF/Motif, modal dialogs will appear with thick borders.
You should use GIA_MODAL dialogs when the application depends on an Interaction being modal to operate correctly. For example, if a dialog shows information about the current selection but the application cannot update that information if the user were to change the current selection, you should use a GIA_MODAL dialog.
You should use
HINT_INTERACTION_MODAL
dialogs for cases where the modality of a dialog simplifies the interface between the application and the user but is not needed for the application's correct operation. The Interaction's modality in this case will make the UI clearer and simpler for the user to understand. For example, a dialog for setting obscure options that is brought up from a command dialog might be marked HINT_INTERACTION_MODAL so that the user is forced to set the options before returning to the command dialog. This will prevent the user from using this dialog box in a context where the options are not self-evident. As with all hints, the Specific UI may decide to ignore the hint and implement a HINT_INTERACTION_MODAL dialog with a non-modal dialog.
You may also initiate a modal dialog with
UserDoDialog()
. Such a dialog must have both the GIA_INITIATED_VIA_USER_DO_DIALOG and GIA_MODAL attributes set. Using this routine not only blocks input to other parts of the application but blocks the calling thread's execution until the dialog is dismissed.
UserDoDialog()
is useful for displaying notifications where the user's response is required before the application's thread may continue. For more information, see Thread Blocking Routines
.
Dialogs displayed with
UserStandardDialog()
and
UserStandardDialogOptr()
are also modal. Both will block the calling thread until the dialog is dismissed. (See Thread Blocking Routines
.)
Some modal dialogs will have subcomponents such as pop-up lists that must be interactable while the dialog is modal. The GenApplication object running the modal dialog will query the dialog to test both its input restrictions and its interactability in these cases; it uses two messages, described below.
Boolean MSG_GEN_INTERACTION_TEST_INPUT_RESTRICTABILITY( optr obj);
This message is called on a modal window by a GenApplication object to find out whether or not the various input restricting mechanisms (input hold-up, input ignore, busy states, etc.) should be overridden or not.
Source: Part of the input flow/modality mechanism--sent by the GenApplication object to the modal window.
Destination: The modal GenInteraction object.
Parameters: obj The optr of the windowed object that may or may not be restricted.
Return: Will return
true
if input restrictions should be overridden, false otherwise. A
true
return value indicates that mouse and keyboard input will flow to the object regardless of hold-up, ignore, or busy states.
Interception: May be intercepted to allow the passed windowed object to override its input restrictions in certain cases.


|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| Interpreter | A semantic bytecode interpreter. |
| Value | An immutable symbolic value for semantic interpretation of bytecode. |
| Class Summary | |
|---|---|
| Analyzer | A semantic bytecode analyzer. |
| BasicInterpreter | An Interpreter for BasicValue values. |
| BasicValue | A Value that is represented by its type in a seven types type system. |
| BasicVerifier | An extended BasicInterpreter that checks that bytecode instructions
are correctly used. |
| Frame | A symbolic execution stack frame. |
| SimpleVerifier | An extended BasicVerifier that performs more precise verifications. |
| SourceInterpreter | An Interpreter for SourceValue values. |
| SourceValue | A Value that is represented by its type in a two types type system. |
| Exception Summary | |
|---|---|
| AnalyzerException | Thrown if a problem occurs during the analysis of a method. |
Provides a framework for static code analysis based on the asm.tree package.
Basic usage:
ClassReader cr = new ClassReader(bytecode); ClassNode cn = new ClassNode(); cr.accept(cn, ClassReader.SKIP_DEBUG); List methods = cn.methods; for (int i = 0; i < methods.size(); ++i) { MethodNode method = (MethodNode) methods.get(i); if (method.instructions.size() > 0) { Analyzer a = new Analyzer(new BasicInterpreter()); a.analyze(cn.name, method); Frame[] frames = a.getFrames(); // Elements of the frames arrray now contains info for each instruction // from the analyzed method. BasicInterpreter creates BasicValue, that // is using simplified type system that distinguishes the UNINITIALZED, // INT, FLOAT, LONG, DOUBLE, REFERENCE and RETURNADDRESS types. ... } }
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Static Image Layer example
You can load an static image (no tiles) easily, look at the source of the
layer
object:


| Implementation Steps | |
|---|---|
| 1. | Laying a Foundation (IBrokerageFactory) Stub out the implementation and initialize a brokerage instance. |
| 2. | Creating The Brokerage (IBrokerage) Installing key brokerage application logic, where possible using a brokerage SDK. |
| 3. | Translating Symbol Conventions (ISymbolMapper) Translate brokerage specific tickers to LEAN format for a uniform algorithm design experience. |
| 4. | Describe Broker Limitations (IBrokerageModel) Describe brokerage support of orders and set transaction models. |
| 5. | Enable Live Data Streaming (IDataQueueHandler) Live streaming data service from brokerage supplied source. |
| 6. | Enable Serving Historical Data (IHistoryProvider) Tap into the brokerage historical data API to serve history for live algorithms. |
| 7. | Download Data (IDataDownloader) Save data from the brokerage to disk in LEAN format. |
| 8. | Describe Brokerage Fee Structures (IFeeModel) Enable accurate backtesting with specific fee structures of the brokerage. |
| 9. | Update Algorithm API for Easy Setup of Brokerage Models (ISecurityTransactionModel) Combine the various models together to form a brokerage set. |
The root of the brokerage system is the algorithm job packets. These hold configuration information about how to run LEAN. The program logic is a little convoluted; it moves from config.json > create job packet > create brokerage factory matching name > set job packet brokerage data > factory creates brokerage instance. Because of this we'll start creating a brokerage at the root -- the configuration and brokerage factory...


The following are some of the organizations and individuals who have contributed to the
HTML components:
| SkyLine Tools, Inc. | ImageLib Graphics Library |
| Radek Przybyl | Ideas and code for establishing Print margins |
| Theodor Kleynhans | Animated GIF code |
| Chris Wallace | Print preview ideas and code |
| Yves Urbain | The Connection concept for protocol support |
| Anders Melander | Color dithering code in DitherUnit.Pas |
| Gustavo Daud | PngImage.pas and PngZLIB.pas |
| Ron Collins | GIF image code |
| Mike Lischke | Unicode routines and assistance |
| jrsoftware.org | Inno Installer |


ICD10gm is an R Package for working with the German Modification of the International Statistical Classification of Diseases and Related Health Problems (ICD-10-GM).
The ICD-10 classification is an international standard for the coding of health service data. It is used widely both to document morbidity in healthcare systems, usually in the context of remuneration claims, and to encode mortality statistics. In Germany, the German Instutite of Medical Documentation and Information (DIMDI) releases a German Modification (ICD-10-GM) of the classification that forms a compulsory part of all remuneration claims in the ambulatory and hospital sectors. Further information and historical context can be found in, for example, Graubner (2007) or Jetté et al (2010).
This package was created to facilitate the analysis of data coded using the ICD-10-GM. In particular, it has the following aims:
ICD10gm is designed for use in the context of medical and health services research using routinely collected claims data. It is not suitable for use in operative coding as it does not include all relevant metadata (e.g. inclusion and exclusion notes and the detailed definitions of psychiatric diagnoses). The metadata provided in the ICD10gm package is not intended to replace the official DIMDI documentation, which should always be consulted when specifying ICD codes for analysis.
The following presents an overview of the basic functionality provided by the ICD10gm package, illustrated by means of simple examples. To access this vignette in R, type:
vignette("icd10gm_intro", package = "ICD10gm")
The ICD-10-GM metadata are provided by four data.frames that form the core of the ICD10gm package:
icd_meta_chapters
: Specification of the ICD-10-GM
chapters with label and number (Arabic and Roman numerals)icd_meta_blocks
: Specification of the ICD-10 blocks,
each containing a sequence of related ICD-10 codesicd_meta_codes
: Extended metadata for all ICD-10-GM
codesicd_meta_transitions
: The “crosswalk” table specifying
old and new ICD-10-GM codes for successive annual versions.Documentation for the individual datasets can be accessed using the R
help system by typing, for example, either
help("icd_meta_codes", package = "ICD10gm")
or simply
?icd_meta_codes
.
While column names have been translated into English, the ICD-10-GM labels are in German with UTF-8 character encoding throughout.
In addition to this tabular data, several utility functions are provided to perform common queries on the metadata.
icd_lookup
(lookup ICD-10 code in console), icd_browse
(lookup
ICD-10-GM in the official Online documentation) and
icd_search
(search through the ICD-10-GM labels).icd_showchanges
and icd_showchanges_icd3
query
icd_meta_transitions
and return entries that are affected
by changes in the ICD-10-GM versions.First, we load the ICD10gm package alongside some tidyverse packages:
library(dplyr)
library(purrr)
library(tidyr)
library(ICD10gm)
By way of example, we examine the coding of unspecific gastroenteritis (i.e. without identification of a specific cause), a very common diagnosis in primary care. We can look up the appropriate code as follows:
icd_search("gastroenteritis", level = 3)
#> year icd3 icd_sub
#><PHONE_NUMBER> A09 A09
#><PHONE_NUMBER> K52 K52
#> label
#> 299205 Sonstige und nicht näher bezeichnete Gastroenteritis und Kolitis infektiösen und nicht näher bezeichneten Ursprungs
#> 304723 Sonstige nichtinfektiöse Gastroenteritis und Kolitis
We see that A09 is used for infectious gastroenteritis, whereas K52 corresponds to non-infectious gastroenteritis. We are interested in A09, but might wish to read up on the details in the official documentation:
icd_browse("A09")
This will open the documentation in our system’s default browser.
Now, we check whether whether this code has been affected by code transitions in any revision since 2003:
icd_showchanges_icd3("A09") %>%
::kable(row.names = FALSE) knitr
| year_from | year_to | icd_from | icd_to | automatic_forward | automatic_backward | change_5 | change_4 | change_3 | change | icd3 | icd_kapitel |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 2009 | 2010 | A09 | A09.0 | A | TRUE | FALSE | FALSE | TRUE | A09 | A | |
| 2009 | 2010 | A09 | A09.9 | TRUE | FALSE | FALSE | TRUE | A09 | A | ||
| 2009 | 2010 | K52.9 | A09.9 | FALSE | FALSE | TRUE | TRUE | A09 | A |
Diagnoses that, prior to 2009, were coded as K52.9 are now coded as A09.9. We can investigate exactly what changed by looking the relevant codes for the years 2009 and 2010:
get_icd_labels(icd3 = c("A09", "K52"), year = 2009:2010) %>%
arrange(year, icd_sub) %>%
filter(icd_sub %in% c("K529") | icd3 == "A09") %>%
select(year, icd_normcode, label) %>%
::kable(row.names = FALSE) knitr
| year | icd_normcode | label |
|---|---|---|
| 2009 | A09 | Diarrhoe und Gastroenteritis, vermutlich infektiösen Ursprungs |
| 2009 | K52.9 | Nichtinfektiöse Gastroenteritis und Kolitis, nicht näher bezeichnet |
| 2010 | A09 | Sonstige und nicht näher bezeichnete Gastroenteritis und Kolitis infektiösen und nicht näher bezeichneten Ursprungs |
| 2010 | A09.0 | Sonstige und nicht näher bezeichnete Gastroenteritis und Kolitis infektiösen Ursprungs |
| 2010 | A09.9 | Sonstige und nicht näher bezeichnete Gastroenteritis und Kolitis nicht näher bezeichneten Ursprungs |
| 2010 | K52.9 | Nichtinfektiöse Gastroenteritis und Kolitis, nicht näher bezeichnet |
Prior to 2010, A09 had been reserved for gastroenteritis of presumed infectious origin (German: vermutlich infektiösen Ursprungs), with unspecified gastroenteritis coded by K52.9. Since 2010, A09.9 codes any unspecified gastroenteritis, with K52.9 reserved for cases determined to be non-infectious. The effect of this change is that A09.9 has replaced K52.9 as the unspecific code used to document the vast majority of routine cases in primary care. Failure to account for this would constitute a major error in medical or epidemiological research.
The function is_icd_code
tests whether a character
vector represents a valid ICD-10-GM code (i.e. a code listed in the
data.frame icd_meta_codes
, allowing for alternative code
specifications). The test may be limited to a particular version of the
ICD-10-GM by specifying the year
argument.
The function is_icd_code
recognises ICD codes regardless
of their formatting, returning TRUE
if the string is
recognised as an ICD code and FALSE
otherwise:
is_icd_code(c("E10.1", "E101", "E10.1-", "J44", "This is not an ICD code"))
#> [1] TRUE TRUE TRUE TRUE FALSE
The function icd_parse
extracts all ICD-10 codes from an
arbitrary character vector. On the one hand, this may be used as in the
icd_expand
function to convert ICD-10 codes to a
standardised format or extract parts of the code. On the other hand, it
may be used to extract potentially many ICD-10 codes from any document
that can be converted to text format (perhaps using the pdftools
package to scrape a PDF document or rvest
to scrape a website).
As an example of how ICD10gm can be used to extract ICD codes from arbitrary text, the following code uses the rvest package to scrape the code block “A00-A09” from the online version of the DIMDI ICD-10-GM reference. We apply the filter to exclude codes below A10, thus revealing which other ICD-10 codes are reference from this block. To simply the package building process, the code has not been evaluated. This is left as an exercise to the reader.
library(dplyr)
library(rvest)
read_html("https://www.dimdi.de/static/de/klassifikationen/icd/icd-10-gm/kode-suche/htmlgm2018/block-a00-a09.htm") %>%
html_text() %>%
icd_parse(type = "bounded") %>%
select(-icd_spec) %>%
unique() %>%
filter(icd_sub >= "A10") %>%
arrange(icd_sub) %>%
left_join(
get_icd_labels(year = 2018)[, c("icd_sub", "icd_normcode", "label")],
by = "icd_sub") %>%
select(icd_normcode, label) %>%
::kable(row.names = FALSE,
knitrcaption = "Additional ICD-10 codes referred to in block A00-A09 (Intestional infectious diseases) of the ICD-10-GM (2018).")
The function icd_expand
takes a data.frame containing
ICD codes and optional metadata as input. It returns a data.frame
containing all ICD codes at or below the specified level of the
hierarchy (e.g. the specification “E11” is expanded to include all
three, four and five-digit codes beginning with E11). Expansion is done
within a specified version of the ICD-10-GM (e.g. year 2018).
Irritable bowel syndrome is coded using either the three-digit code K58 (conceiving IBS as the somatic condition) or the code F45.32 (focussing on IBS as a psychosomatic condition). We can retrieve all subcodes in the year 2019 as follows:
<- data.frame(DIAG_GROUP = c("IBS", "IBS"), ICD_SPEC = c("K58", "F45.32")) %>%
icd_k58 icd_expand(col_icd = "ICD_SPEC", year = 2019, col_meta = "DIAG_GROUP")
::kable(icd_k58) knitr
| icd_spec | DIAG_GROUP | year | icd3 | icd_code | icd_normcode | icd_sub | label |
|---|---|---|---|---|---|---|---|
| K58 | IBS | 2019 | K58 | K58.- | K58 | K58 | Reizdarmsyndrom |
| K58 | IBS | 2019 | K58 | K58.1 | K58.1 | K581 | Reizdarmsyndrom, Diarrhoe-prädominant [RDS-D] |
| K58 | IBS | 2019 | K58 | K58.2 | K58.2 | K582 | Reizdarmsyndrom, Obstipations-prädominant [RDS-O] |
| K58 | IBS | 2019 | K58 | K58.3 | K58.3 | K583 | Reizdarmsyndrom mit wechselnden (gemischten) Stuhlgewohnheiten [RDS-M] |
| K58 | IBS | 2019 | K58 | K58.8 | K58.8 | K588 | Sonstiges und nicht näher bezeichnetes Reizdarmsyndrom |
| F4532 | IBS | 2019 | F45 | F45.32 | F45.32 | F4532 | Somatoforme autonome Funktionsstörung: Unteres Verdauungssystem |
Note that the data.frame
containing the specification
should normally be stored as a separate metadata file (eg. csv or Excel
format) to facilitate maintenance and sharing of the specification. The
column DIAG_GROUP
is a label that can be allocated to one
or multiple rows of the specification and is useful when aggregating
diagnoses. This is similar to the concept of diagnosis groupers used,
for example, in risk adjustment schemes (e.g. as operated by the German
Federal Social Insurance Office). In this case, we may want to treat
the two alternative codes as equivalent by allocating the label “IBS” to
both. In this way, we overcome the common problem that, in practice,
multiple codes are used to document the same underlying disease.
The function icd_history
takes the result of
icd_expand
, specified for a particular year, and returns a
data.frame containing all corresponding codes for the specified years
(from 2003). To do this, it applies the ICD-10-GM transition tables to
map codes between successive ICD-10-GM versions. Only automatic
transitions are followed to ensure that the specification retains its
meaning. Custom transitions, tailored to the needs of the project at
hand, can be specified to yield a more complete history.
We historise the code K58, specified for the year 2019, backwards to obtain the corresponding codes for the years 2017 to 2019:
icd_history(icd_k58, years = 2017:2019) %>%
select(icd_spec, DIAG_GROUP, year, icd_code) %>%
arrange(year, icd_code)
#> # A tibble: 12 × 4
#> icd_spec DIAG_GROUP year icd_code
#> <chr> <chr> <int> <chr>
#> 1 F4532 IBS 2017 F45.32
#> 2 K58 IBS 2017 K58.0
#> 3 K58 IBS 2017 K58.9
#> 4 F4532 IBS 2018 F45.32
#> 5 K58 IBS 2018 K58.0
#> 6 K58 IBS 2018 K58.9
#> 7 F4532 IBS 2019 F45.32
#> 8 K58 IBS 2019 K58.-
#> 9 K58 IBS 2019 K58.1
#> 10 K58 IBS 2019 K58.2
#> 11 K58 IBS 2019 K58.3
#> 12 K58 IBS 2019 K58.8
Program code is released under the MIT license.
The underlying ICD-10-GM metadata is copyright of the German Instutite of Medical Documentation and Information (DIMDI). The source files are available free of charge from the DIMDI Download Centre. I believe that their use in this package is compatible with the copyright restrictions. In particular:
The distribution of an “added-value product” derived from the original DIMDI classification files is expressly permitted.
Distribution of the original classification files is forbidden. Consequently, this package distributes only the code required to process these files. Those wishing to compile the data from scratch must download the files from the DIMDI download centre and agree to the copyright restrictions.
The package does not modify the ICD-10-GM codes, texts or other metadata in any way other than to restructure the data into a convenient form.
The package does not contain any commercial advertising.
The source of the data is clearly stated, both here and in the main package documentation.
The ICD10gm package provides a convenient means of accessing and manipulating the German modification of the ICD-10 classification. It is designed for use in medical, epidemiological and health services research.
To the author’s knowledge, this package represents the only publicly available repository of pre-processed metadata for the ICD-10-GM. Indeed, a key contribution of the package is the compilation and processing of the metadata provided by DIMDI, which is designed more for the needs of operational use than for the purpose of longitudinal secondary data analysis.
Building on the metadata, the ICD10gm package provides various functions to facilitate the analysis of ICD-10 data. Possible uses include:
Calculating the administrative prevalence of diseases over time, accounting for changes to the ICD-10-GM classification.
The extraction of ICD-10 codes for the purposes of text mining.
The implementation of diagnoses grouping systems for the representation of patient morbidity.
citation(package = "ICD10gm")
#>
#> Um Paket 'ICD10gm' in Publikationen zu zitieren, nutzen Sie bitte:
#>
#> Donnachie E (2023). _ICD10gm: Metadata Processing for the German
#> Modification of the ICD-10 Coding System_.
#> https://edonnachie.github.io/ICD10gm/,
#> https://doi.org/10.5281/zenodo.2542833.
#>
#> Ein BibTeX-Eintrag für LaTeX-Benutzer ist
#>
#> @Manual{,
#> title = {ICD10gm: Metadata Processing for the German Modification of the ICD-10 Coding System},
#> author = {Ewan Donnachie},
#> year = {2023},
#> note = {https://edonnachie.github.io/ICD10gm/, https://doi.org/10.5281/zenodo.2542833},
#> }


| FinalProject Index | LINK HERE |
| T4A02-maze-khalile | LINK HERE |
| T4A03-win-and-checkAll-khalil | LINK HERE |
| T4A04-Wasd-khalil | LINK HERE |
| T4A05-Bounce-khalil | LINK HERE |
| T4A06-Scoring-khalil | LINK HERE |
| T4A07-Random-khalil | LINK HERE |
| T4A08-Random-Screen-khalil | LINK HERE |
| T4A09-Random-better-khalil | LINK HERE |
| T4A10-gravity-khalil-ayach | LINK HERE |
| T4A11-concle.log | LINK HERE |
| T4A12-canvas | LINK HERE |
| T4a13-rotation-khalil-ayach | LINK HERE |
| T4a14-image-drag-khalil-ayach | LINK HERE |
| T4a15-snake-khalil-ayach | LINK HERE |
| T4a16-Bullet-khalil-ayach | LINK HERE |
| T4a17-Flappy-Birds-khalil-ayach | LINK HERE |
| MachineLearning | LINK HERE |
| Construct | LINK HERE |
| T3A03-website-khalil | LINK HERE |
| My Github | LINK HERE |
| My Index On Github | LINK HERE |
| T3A05-Forms | LINK HERE |
| T3A06-CSS | LINK HERE |
| T3A07-Code | LINK HERE |
| T3A08-Overview | LINK HERE |
| T3A09-Event | LINK HERE |
| T3A10-InputOutput | LINK HERE |
| T3A11-Veriable | LINK HERE |
| T3A12-Decision | LINK HERE |
| T3A13-Functions | LINK HERE |
| T3A14-Loop | LINK HERE |
| T3A15-Array | LINK HERE |
| T3A16-Object | LINK HERE |
| T3A17-Classes | LINK HERE |
| T3A18-Sound | LINK HERE |


Lua - Tables
Introduction
Tables are the only data structure available in Lua that helps us create different types like arrays and dictionaries. Lua uses associative arrays and which can be indexed with not only numbers but also with strings except nil. Tables have no fixed size and can grow based on our need.
Lua uses tables in all representations including representation of packages. When we access a method string.format, it means, we are accessing the format function available in string package.
Representation and Usage
Tables are called objects and they are neither values nor variables. Lua uses a constructor expression {} to create an empty table. It is to be know that there is no fixed relationship between a variable that holds reference of table and the table itself.
--sample table initialization mytable = {} --simple table value assignment mytable[1]= "Lua" --removing reference mytable = nil -- lua garbage collection will take care of releasing memory
When we have a table a with set of elements and if we assign it to b, both a and b refer to the same memory. No separate memory is allocated separately for b. When a is set to nil, table will be still accessible to b. When there are no reference to a table, then garbage collection in Lua takes care of cleaning up process to make these unreferenced memory to be reused again.
An example is shown below for explaining the above mentioned features of tables.
-- Simple empty table mytable = {} print("Type of mytable is ",type(mytable)) mytable[1]= "Lua" mytable["wow"] = "Tutorial" print("mytable Element at index 1 is ", mytable[1]) print("mytable Element at index wow is ", mytable["wow"]) -- alternatetable and mytable refers to same table alternatetable = mytable print("alternatetable Element at index 1 is ", alternatetable[1]) print("mytable Element at index wow is ", alternatetable["wow"]) alternatetable["wow"] = "I changed it" print("mytable Element at index wow is ", mytable["wow"]) -- only variable released and and not table alternatetable = nil print("alternatetable is ", alternatetable) -- mytable is still accessible print("mytable Element at index wow is ", mytable["wow"]) mytable = nil print("mytable is ", mytable)
When we run the above program we will get the following output
Type of mytable is table mytable Element at index 1 is Lua mytable Element at index wow is Tutorial alternatetable Element at index 1 is Lua mytable Element at index wow is Tutorial mytable Element at index wow is I changed it alternatetable is nil mytable Element at index wow is I changed it mytable is nil
Table manipulation
There are in built functions for table manipulation and they are listed in the following table.
| S.N. | Method & Purpose |
|---|---|
| 1 | table.concat (table [, sep [, i [, j]]]): Concatenates the strings in the tables based on the parameters given. See example for detail. |
| 2 | table.insert (table, [pos,] value): Inserts a value into the table at specified position. |
| 3 | table.maxn (table) Returns the largest numeric index. |
| 4 | table.remove (table [, pos]) Removes the value from the table. |
| 5 | table.sort (table [, comp]) Sorts the table based on optional comparator argument. |
The following example brings out the example for table functions.
fruits = {"banana","orange","apple"} -- returns concatenated string of table print("Concatenated string ",table.concat(fruits)) --concatenate with a character print("Concatenated string ",table.concat(fruits,", ")) --concatenate fruits based on index print("Concatenated string ",table.concat(fruits,", ", 2,3)) -- insert a fruit at the end table.insert(fruits,"mango") print("Fruit at index 4 is ",fruits[4]) --insert fruit at index 2 table.insert(fruits,2,"grapes") print("Fruit at index 2 is ",fruits[2]) print("The maximum elements in table is",table.maxn(fruits)) print("The last element is",fruits[5]) table.remove(fruits) print("The previous last element is",fruits[5]) for k,v in ipairs(fruits) do print(k,v) end table.sort(fruits) print("sorted table") for k,v in ipairs(fruits) do print(k,v) end
When we run the above program we will get the following output
Concatenated string bananaorangeapple Concatenated string banana, orange, apple Concatenated string orange, apple Fruit at index 4 is mango Fruit at index 2 is grapes The maximum elements in table is 5 The last element is mango The previous last element is nil 1 banana 2 grapes 3 orange 4 apple sorted table 1 apple 2 banana 3 grapes 4 orange