Bibulous is a drop-in replacement for BibTeX, with the primary advantage that the bibliography template format is compact and very easy to modify.
The basic program flow upon object initialization is as follows:
Reduce the case of the string to lower case, except for the first character in the string, and except if any given character is at nonzero brace level.
| Parameters: | s : str
|
|---|---|
| Returns: | t : str
|
Split a string into tokens, taking care not to allow the separator to act unless at brace level zero.
| Parameters: | s : str
|
|---|---|
| Returns: | tokens : list of str
|
Parse a name field (“author” or “editor”) of a BibTeX entry into a list of dicts, one for each person.
| Parameters: | namefield : str
key : str, optional
sep : str, optional
disable : list of int, optional
|
|---|---|
| Returns: | namelist : list
|
Take a BibTeX string representing a single person’s name and parse it into its first, middle, last, etc pieces.
So, we can separate these three categories by counting the number of commas that appear.
| Parameters: | namestr : str
disable : list of int, optional
|
|---|---|
| Returns: | namedict : dict
|
From an input name element (first, middle, prefix, last, or suffix) , convert it to its initials.
| Parameters: | name : str
options : dict of bools, optional
|
|---|---|
| Returns: | new_name : str
|
Generate a list of level numbers for each character in a string.
| Parameters: | s : str
delims : tuple of two strings
operator : str
|
|---|---|
| Returns: | levels : list of ints
|
A debugging tool for showing delimiter levels and the input string next to one another.
| Parameters: | s : str
levels : list of ints
|
|---|
Return a list which gives the “quotation level” of each character in the string.
| Parameters: | s : str
disable : list of ints, optional
|
|---|---|
| Returns: | alevels : list of ints
blevels : list of ints
clevels : list of ints
|
Notes
When using double-quotes, it is easy to break the parser, so they should be used only sparingly.
Split a string at locations given by a list of indices.
This can be used more flexibly than Python’s native string split() function, when the character you are splitting on is not always a valid splitting location.
| Parameters: | s : str
ilist : list
|
|---|---|
| Returns: | slist : list of str
|
Split a string using more than one separator.
Copied from http://stackoverflow.com/questions/1059559/python-strings-split-with-multiple-separators.
| Parameters: | s : str
sep : list of str
|
|---|---|
| Returns: | res : list
|
This function will return the input string if it finds there are no nested operators inside (i.e. when the number of delimiters found is < 2).
| Parameters: | s : str
delims : tuple of two strings
odd_operator : str
even_operator : str
disable : list of int, optional
|
|---|---|
| Returns: | s : str
|
Find nested quotes within strings and, if necessary, replace them with the proper nesting (i.e. outer quotes use ``...'' while inner quotes use `...').
| Parameters: | s : str
disable : list of int, optional
|
|---|---|
| Returns: | s : str
|
Remove the LaTeX-based formatting elements from a string so that a sorting function can use alphanumerical sorting on the string.
| Parameters: | s : str
|
|---|---|
| Returns: | p : str
|
Translate LaTeX-markup special characters to their Unicode equivalents.
| Parameters: | s : str
|
|---|---|
| Returns: | s : str
|
From the middle name of a single person, check if any of the names should be placed into the “prefix” and move them there.
| Parameters: | namedict : dict
|
|---|---|
| Returns: | namedict : dict
|
Given a bibliography entry’s edition number, format it as an ordinal (i.e. “1st”, “2nd” instead of “1”, “2”) in the way that it will appear on the formatted page.
| Parameters: | edition_field : str
disable : list of int, optional
|
|---|---|
| Returns: | edition_ordinal_str : str
|
Write a bibliography database dictionary into a .bib file.
| Parameters: | filename : str
bibdata : dict
abbrevs : dict, optional
|
|---|
Given a string containing the “pages” field of a bibliographic entry, figure out the start and end pages.
| Parameters: | pages_str : str
citekey : str, optional
disable : list of int, optional
|
|---|---|
| Returns: | startpage : str
endpage : str
|
Given a string containing either a single “name” > “abbreviation” pair or a list of such pairs, parse the string into a dictionary of names and abbreviations.
| Parameters: | abbrevstr : str
|
|---|---|
| Returns: | nameabbrev_dict : dict
|
Remove elements from a Python script which are provide the most egregious security flaws; also replace some identifiers with their correct namespace representation.
| Parameters: | line : str
|
|---|---|
| Returns: | filtered : str
|
Check is an input string represents an integer value. Although a trivial function, it will be useful for user scripts.
| Parameters: | s : str
|
|---|---|
| Returns: | is_integer : bool
|
Print a warning message, with the option to disable any given message.
| Parameters: | msg : str
disable : list of int, optional
|
|---|
Create an “alpha” style citation key (typically the first three letters of the author’s last name, followed by the last two numbers of the year).
| Parameters: | entry : dict
options : dict
|
|---|---|
| Returns: | alpha : str
|
Split a string, but only if the splitting character is at level 0 or 1 and not higher.
| Parameters: | s : str
splitchar : str
levels : list of ints
|
|---|---|
| Returns: | split_list : list of str
|
Split the variable name into “name” (left-hand-side part), “iterator” (middle part), and “remainder” (the right- hand-side part).
With these three elements, we will know how to build a template variable inside the implicit loop.
| Parameters: | variable : str
|
|---|---|
| Returns: | var_dict : dict
|
Get the list of names associated with a given entry, giving priority to the first namelist present in the “namelists” list.
| Parameters: | entry : dict
templatestr : str
|
|---|---|
| Returns: | namelist : list of dicts
|
Format a list of dictionaries (one dict for each person) into a long string, with the format according to the directives in the bibliography style template.
| Parameters: | namelist : str
nametype : str, {‘author’, ‘editor’}, optional
options : dict, optional
|
|---|---|
| Returns: | namestr : str
|
Convert a name dictionary into a formatted name string.
| Parameters: | namedict : dict
options : dict, optional
|
|---|---|
| Returns: | namestr : str
|
Return the indices for producing a sorted list.
| Parameters: | seq : iterable
reverse : bool
|
|---|---|
| Returns: | idx : list of ints
|
Create an alphanumeric style citation key (the first letter of the author’s last name, followed by a number giving the sort order).
Warning: do not run this function on a large database of citations — it is not optimized for that use and will take quite a while to complete.
| Parameters: | entry : dict
bibdata : dict
citelist : list of str
|
|---|---|
| Returns: | citelabels : str
|
From a template containing an implicit loop (‘...’ notation), build a full-size template without an ellipsis.
Right now, the code only allows one implicit loop in any given template.
| Parameters: | templatestr : str
|
|---|---|
| Returns: | loop_data : dict
|
Bibdata is a class to hold all data related to a bibliography database, a citation list, and a style template.
To initialize the class, either call it with the filename of the .aux file containing the relevant file locations (for the .bib database files and the .bst template files) or simply call it with a list of all filenames to be used (i.e. database_name.bib, style_template_name.bst and main_filename.aux). The output file (the LaTeX- formatted bibliography) is assumed to have the same filename root as the .aux file, but with .bbl as its extension.
Attributes
| abbrevs | dict | The list of abbreviations given in the bibliography database file(s). The dictionary keys are the abbreviations, and the values are their full forms. |
| bibdata | dict | The database of bibliography entries and fields derived from parsing the bibliography database file(s). |
| bstdict | dict | The style template for formatting the bibliography. The dictionary keys are the entrytypes, with the dictionary values their string template. |
| citedict | dict | The dictionary of citation keys, and their corresponding numerical order of citation. |
| debug | bool | Whether to turn on debugging features. |
| filedict | dict | The ditionary of filenames associated with the bibliographic data. The dictionary consists of keys bib, bst, aux, tex, and bbl. The first two are lists of filenames, while the others contain only a single filename. |
| filename | str | (For error messages and debugging) The name of the file currently being parsed. |
| i | int | (For error messages and debugging) The line of the file currently being parsed. |
| options | dict | The dictionary containing the various option settings from the style template (BST) files. |
| specials | dict | The dictionary containing the special templates from the BST file(s). |
| abbrevkey_pattern | compiled regular expression object | The regex used to search for abbreviation keys. |
| anybrace_pattern | compiled regular expression object | The regex used to search for curly braces { or }. |
| anybraceorquote_pattern | compiled regular expression object | The regex used to search for curly braces or for double-quotes, i.e. {, }, or “. |
| endbrace_pattern | compiled regular expression object | The regex used to search for an ending curly brace, i.e. ‘}’. |
| quote_pattern | compiled regular expression object | The regex used to search for a double-quote, i.e. “. |
| startbrace_pattern | compiled regular expression object | The regex used to search for a starting curly brace, {. |
| culldata | bool | Whether to cull the database so that only cited entries are parsed. Setting this to False means that the entire BIB file database will be parsed. When True, the BIB file parser will only parse those entries corresponding to keys in the citedict. Setting this to True provides significant speedups for large databases. |
| parse_only_entrykeys | bool | When comparing a database file against a citation list, all we are initially interested in are the entrykeys and not the data. So, in our first pass through the database, we can use this flag to skip the data and get only the keys themselves. |
Methods
| parse_bibfile(filename) | Parse a ”.bib” file to generate a dictionary representing a bibliography database. |
| parse_bibentry(entrystr, entrytype) | Given a string representing the entire contents of the BibTeX-format bibliography entry, parse the contents and place them into the bibliography preamble string, the set of abbreviations, and the bibliography database dictionary. |
| parse_bibfield(entrystr[, entrykey]) | For a given string representing the raw contents of a BibTeX-format bibliography entry, parse the contents into a dictionary of key:value pairs corresponding to the field names and field values. |
| parse_auxfile(filename[, debug]) | Read in an .aux file and convert the citation{} entries found there into a dictionary of citekeys and citation order number. |
| parse_bstfile(filename) | Convert a Bibulous-type bibliography style template into a dictionary. |
| write_bblfile([filename, write_preamble, ...]) | Given a bibliography database bibdata, a dictionary containing the citations called out citedict, and a bibliography style template bstdict write the LaTeX-format file for the formatted bibliography. |
| create_citation_list() | Create the list of citation keys, sorted into the proper order. |
| format_bibitem(citekey[, debug]) | Create the “ibitem{...}” string to insert into the ”.bbl” file. |
| insert_crossref_data(entrykey[, fieldname]) | Insert crossref info into a bibliography database dictionary. |
| write_citeextract(outputfile[, write_abbrevs]) | Extract a sub-database from a large bibliography database, with the former containing only those entries cited in the .aux file (and any relevant cross-references). |
| write_authorextract(searchname[, ...]) | Extract a sub-database from a large bibliography database, with the former containing only those entries citing the given author/editor. |
| replace_abbrevs_with_full(fieldstr, resultstr) | Given an input str, locate the abbreviation key within it and replace the abbreviation with its full form. |
| get_bibfilenames(filename) | If the input is a filename ending in .aux, then read through the .aux file and locate the lines ibdata{...} and ibstyle{...} to get the filename(s) for the bibliography database and style template. |
| check_citekeys_in_datakeys() | Check to see if all of the citation keys (from the AUX file) exist within the current set of database entrykeys. |
| add_crossrefs_to_searchkeys() | Add any cross-referenced entrykeys into the searchkeys, the list which is used to cull the database so that only necessary entries are parsed. |
| insert_specials(entrykey) | Insert “special” fields into a database entry. |
| validate_templatestr(templatestr, key) | Validate the template string so that it contains no formatting errors. |
| fillout_implicit_indices(templatestr, entrykey) | From a template containing an implicit loop (‘...’ notation), build a full-size template without an ellipsis. |
| template_substitution(templatestr, entrykey) | Substitute database entry variables into template string. |
| insert_title_into_template(title_var, ...) | Insert the title field into a template string. |
| remove_nested_template_options_brackets(...) | Given a template string, go through each options sequence [...] and search for undefined variables. |
| remove_template_options_brackets(...) | Given a template string, go through each options sequence [...] and search for undefined variables. |
| simplify_template_bracket(templatestr, ...) | From an “options train” [...|...|...], find the first fully defined block in the sequence. |
| get_variable(bibentry, variable[, options]) | Get the variable (i.e. |
| get_indexed_variable(field, indexer[, ...]) | Get the result of dot-indexing into a field. |
| get_indexed_vars_in_template(templatestr) | Get a list of the indexed variables within a template. |
Add any cross-referenced entrykeys into the searchkeys, the list which is used to cull the database so that only necessary entries are parsed.
Check to see if all of the citation keys (from the AUX file) exist within the current set of database entrykeys.
| Returns: | is_complete : bool
|
|---|
From a template containing an implicit loop (‘...’ notation), build a full-size template without an ellipsis.
Right now, the code only allows one implicit loop in any given template.
| Parameters: | templatestr : str
entrykey : str
templatekey : str
|
|---|---|
| Returns: | new_templatestr : str
|
Create the “ibitem{...}” string to insert into the ”.bbl” file.
This is the workhorse function of Bibulous. For a given citation key, find the resulting entry in the bibliography database. From the entry’s entrytype, lookup the relevant template in bstdict and start replacing template variables with formatted elements of the database entry. Once you’ve replaced all template variables, you’re done formatting that entry. Write the result to the BBL file.
| Parameters: | citekey : str
|
|---|---|
| Returns: | itemstr : str
|
If the input is a filename ending in .aux, then read through the .aux file and locate the lines ibdata{...} and ibstyle{...} to get the filename(s) for the bibliography database and style template.
Also determine whether to set the culldata flag. If the input is a single AUX filename, then the default is to set culldata=True. If the input is a list of filenames, then assume that this is the complete list of files to use (i.e. ignore the contents of the AUX file except for generating the citedict), and set culldata=False.
| Parameters: | filename : str
|
|---|---|
| Returns: | filedict : dict
|
Get the result of dot-indexing into a field. This can be accessing an element of a list or dictionary, or the result of operating on a string with a function.
| Parameters: | field : str
indexer : str
entrykey : str
options : dict
|
|---|---|
| Returns: | result : str
|
Get a list of the indexed variables within a template.
| Parameters: | templatestr : str
|
|---|---|
| Returns: | indexed_vars : list of str
|
Get the variable (i.e. entry field) from within the current bibliography entry.
| Parameters: | bibentry : dict
variable : str
options : dict
|
|---|---|
| Returns: | result : str
|
Insert crossref info into a bibliography database dictionary.
Loop through a bibliography database dictionary and, for each entry which has a “crossref” field, locate the crossref entry and insert any missing bibliographic information into the main entry’s fields.
| Parameters: | entrykey : str
fieldname : str, optional
|
|---|---|
| Returns: | foundit : bool
|
Insert “special” fields into a database entry.
| Parameters: | entrykey : str
|
|---|
Insert the title field into a template string.
This requires more work than simply performing a string replacement, because there can be punctuation conflicts when the title itself ends with punctuation, while the template itself has punctuation immediately following the title.
| Parameters: | title_var : str
templatestr : str
bibentry : dict
|
|---|---|
| Returns: | templatestr : str
|
Read in an .aux file and convert the citation{} entries found there into a dictionary of citekeys and citation order number.
| Parameters: | filename : str
|
|---|
Given a string representing the entire contents of the BibTeX-format bibliography entry, parse the contents and place them into the bibliography preamble string, the set of abbreviations, and the bibliography database dictionary.
| Parameters: | entrystr : str
entrytype : str
|
|---|
For a given string representing the raw contents of a BibTeX-format bibliography entry, parse the contents into a dictionary of key:value pairs corresponding to the field names and field values.
| Parameters: | entrystr : str
entrykey : str
|
|---|---|
| Returns: | fd : dict
|
Parse a ”.bib” file to generate a dictionary representing a bibliography database.
| Parameters: | filename : str
|
|---|
Convert a Bibulous-type bibliography style template into a dictionary.
The resulting dictionary consists of keys which are the various entrytypes, and values which are the template strings. In addition, any formatting options are stored in the “options” key as a dictionary of option_name:option_value pairs.
| Parameters: | filename : str
|
|---|
Given a template string, go through each options sequence [...] and search for undefined variables. In each sequence, return only the block of each sequence in which all variables are defined (i.e. with outer braces removed).
| Parameters: | templatestr : str
entry : dict
variables : list of str
|
|---|
Given a template string, go through each options sequence [...] and search for undefined variables. In each sequence, return only the block of each sequence in which all variables are defined.
| Parameters: | templatestr : str
entry : dict
variables : list of str
|
|---|
Given an input str, locate the abbreviation key within it and replace the abbreviation with its full form.
Once the abbreviation key is found, remove it from the “fieldstr” and add the full form to the “resultstr”.
| Parameters: | fieldstr : str
resultstr : str
|
|---|---|
| Returns: | fieldstr : str
resultstr : str
end_of_field : bool
|
From an “options train” [...|...|...], find the first fully defined block in the sequence.
A style template string contains grammatical features of the form [...|...|...], which we can call options sequences. Each “block” in the sequence (divided from the others by a | symbol), contains fields which, if defined, replace the entire options sequence in the returned string.
When the options sequence ends with “|]” (i.e. at least one of the blocks is required to be defined) but we find that none of the blocks have all their variables defined, then we replace the entire block with the “undefstr”.
| Parameters: | templatestr : str
variables : list of str
bibentry : dict
|
|---|---|
| Returns: | arg : str
|
Substitute database entry variables into template string.
| Parameters: | templatestr : str
entrykey : dict
templatekey : str
|
|---|---|
| Returns: | templatestr : str
|
Validate the template string so that it contains no formatting errors.
| Parameters: | templatestr : str
key : str
|
|---|---|
| Returns: | okay : bool
|
Extract a sub-database from a large bibliography database, with the former containing only those entries citing the given author/editor.
| Parameters: | searchname : str or dict
outputfile : str, optional
write_abbrevs : bool
|
|---|
Given the input database file(s) and style file(s), write out an AUX file containing citations to all unique database entries.
This function is only provided as a utility, and is not actually used except during troubleshooting.
| Parameters: | filename : str
|
|---|
Given a bibliography database bibdata, a dictionary containing the citations called out citedict, and a bibliography style template bstdict write the LaTeX-format file for the formatted bibliography.
Start with the preamble and then loop over the citations one by one, formatting each entry one at a time, and put end{thebibliography} at the end when done.
| Parameters: | filename : str, optional
write_preamble : bool, optional
write_postamble : bool, optional
bibsize : str, optional
|
|---|
Extract a sub-database from a large bibliography database, with the former containing only those entries cited in the .aux file (and any relevant cross-references).
| Parameters: | filedict : str
outputfile : str, optional
write_abbrevs : bool
|
|---|


Toggle navigation
URL Shortener
Home
(current)
API
URL Shortener
Long URL
Prefered Shortened URL (Optional. Default is random letters and numbers)
Get Short URL


Coverage Summary for Class: GameEvent (it.polimi.ingsw.model.gameEvents)
1 package it.polimi.ingsw.model.gameEvents;
2
3 import it.polimi.ingsw.model.Game;
4
5 import java.io.Serializable;
6
7 /**
8 * This interface is implements by al the possible events which can occur during the game.
9 * Parts of the model notifies the central class {@link Game} when an event occurs and it
10 * handles it by calling the method on these classes.
11 * It implements {@link Serializable} interface in order to be sent through the network.
12 */
13 public interface GameEvent extends Serializable {
14
15 /**
16 * The method which is called by {@link Game} class in order to handle the event.
17 * Each event overrides it.
18 * @param game the game instance.
19 */
20 void handleEvent(Game game);
21
22 /**
23 * @return the event trigger as a string.
24 */
25 String eventTrigger();
26 }


|
SBF
Super bloody fast messaging transport
|
This file declares the structures and functions of a log system. More...
#include "sbfCommon.h"
Go to the source code of this file.
Macros | |
| #define | sbfLog_err(log, fmt, ...) sbfLog_log (log, SBF_LOG_ERROR, fmt, ## __VA_ARGS__) |
| #define | sbfLog_warn(log, fmt, ...) sbfLog_log (log, SBF_LOG_WARN, fmt, ## __VA_ARGS__) |
| #define | sbfLog_info(log, fmt, ...) sbfLog_log (log, SBF_LOG_INFO, fmt, ## __VA_ARGS__) |
| #define | sbfLog_debug(log, fmt, ...) sbfLog_log (log, SBF_LOG_DEBUG, fmt, ## __VA_ARGS__) |
Typedefs | |
| typedef struct sbfLogImpl * | sbfLog |
| typedef int(* | sbfLogHookCb) (sbfLog log, sbfLogLevel level, const char *message, void *closure) |
| This callback is invoked when hook is set to the log system to intercept logging messages. More... | |
Enumerations | |
| enum | sbfLogLevel { SBF_LOG_DEBUG = 0, SBF_LOG_INFO, SBF_LOG_WARN, SBF_LOG_ERROR, SBF_LOG_OFF } |
Functions | |
| sbfLog | sbfLog_create (struct sbfLogFileImpl *lf, const char *fmt,...) SBF_PRINTFLIKE(2 |
| Creates a log through a formatted string. More... | |
| sbfLog void | sbfLog_destroy (sbfLog log) |
| Releases all the resources allocated by the log's handler. More... | |
| sbfLogLevel | sbfLog_getLevel (sbfLog log) |
| Returns the log's level. More... | |
| void | sbfLog_setLevel (sbfLog log, sbfLogLevel level) |
| Sets the log's level. More... | |
| sbfLogLevel | sbfLog_levelFromString (const char *s, int *found) |
| Converts from string level into level code. In the case that level string is not defined then SBF_LOG_OFF will be returned. More... | |
| const char * | sbfLog_levelToString (sbfLogLevel level) |
| Converts from a code level into null terminated string level. More... | |
| void | sbfLog_log (sbfLog log, sbfLogLevel level, const char *fmt,...) SBF_PRINTFLIKE(3 |
| Logs a message with a given level into the logging system. More... | |
| void void | sbfLog_vlog (sbfLog log, sbfLogLevel level, const char *fmt, va_list ap) |
| Logs a message with a given level into the logging system. More... | |
| void | sbfLog_logData (sbfLog log, sbfLogLevel level, void *buf, size_t len) |
| Logs a chunk of binary data with a given level into the logging system. More... | |
| void | sbfLog_setHook (sbfLog log, sbfLogLevel level, sbfLogHookCb cb, void *closure) |
| Sets a hook to the logging system to intercept the writing of log messages. More... | |
This file declares the structures and functions of a log system.
Definition in file sbfLog.h.
| #define sbfLog_debug | ( | log, | |
| fmt, | |||
| ... | |||
| ) | sbfLog_log (log, SBF_LOG_DEBUG, fmt, ## __VA_ARGS__) |
| #define sbfLog_err | ( | log, | |
| fmt, | |||
| ... | |||
| ) | sbfLog_log (log, SBF_LOG_ERROR, fmt, ## __VA_ARGS__) |
| #define sbfLog_info | ( | log, | |
| fmt, | |||
| ... | |||
| ) | sbfLog_log (log, SBF_LOG_INFO, fmt, ## __VA_ARGS__) |
| #define sbfLog_warn | ( | log, | |
| fmt, | |||
| ... | |||
| ) | sbfLog_log (log, SBF_LOG_WARN, fmt, ## __VA_ARGS__) |
| typedef struct sbfLogImpl* sbfLog |
| typedef int(* sbfLogHookCb) (sbfLog log, sbfLogLevel level, const char *message, void *closure) |
This callback is invoked when hook is set to the log system to intercept logging messages.
| log | the log's handler. |
| level | the log level. |
| message | the message that was hooked. |
| closure | the user data linked to the log's hook. |
| enum sbfLogLevel |
| sbfLog sbfLog_create | ( | struct sbfLogFileImpl * | lf, |
| const char * | fmt, | ||
| ... | |||
| ) |
Creates a log through a formatted string.
| lf | The log file's handler. |
| fmt | the formatted string. |
| ... | the list of arguments for the formatted string. |
Releases all the resources allocated by the log's handler.
| log | the log's handler. |
| sbfLogLevel sbfLog_getLevel | ( | sbfLog | log | ) |
Returns the log's level.
| log | the log's handler. |
| sbfLogLevel sbfLog_levelFromString | ( | const char * | s, |
| int * | found | ||
| ) |
Converts from string level into level code. In the case that level string is not defined then SBF_LOG_OFF will be returned.
| s | null terminated string containing the log level. |
| found | 1 if found, 0 if not found. |
| const char* sbfLog_levelToString | ( | sbfLogLevel | level | ) |
Converts from a code level into null terminated string level.
| level | the level code. |
| void sbfLog_log | ( | sbfLog | log, |
| sbfLogLevel | level, | ||
| const char * | fmt, | ||
| ... | |||
| ) |
Logs a message with a given level into the logging system.
| log | the log's handler. |
| level | the log level. |
| fmt | the formatting string. |
| ... | the parameters for the formatting string. |
| void sbfLog_logData | ( | sbfLog | log, |
| sbfLogLevel | level, | ||
| void * | buf, | ||
| size_t | len | ||
| ) |
Logs a chunk of binary data with a given level into the logging system.
| log | the log's handler. |
| level | the log level. |
| buf | the data to be logged. |
| len | the size of the data in bytes. |
| void sbfLog_setHook | ( | sbfLog | log, |
| sbfLogLevel | level, | ||
| sbfLogHookCb | cb, | ||
| void * | closure | ||
| ) |
Sets a hook to the logging system to intercept the writing of log messages.
| log | the log's handler. |
| level | the log's level. |
| cb | the callback to be invoked before the log is applied. |
| closure | the user data linked to the hook. |
| void sbfLog_setLevel | ( | sbfLog | log, |
| sbfLogLevel | level | ||
| ) |
Sets the log's level.
| log | the log's handler. |
| level | the log's level. |
| void void sbfLog_vlog | ( | sbfLog | log, |
| sbfLogLevel | level, | ||
| const char * | fmt, | ||
| va_list | ap | ||
| ) |
Logs a message with a given level into the logging system.
| log | the log's handler. |
| level | the log level. |
| fmt | the formatting string. |
| ap | the list of arguments for the formatting string. |


Thanks for your participation.
 For each pair, please choose the one which you think is older.
You can choose "Equal Ages" for cases that you think they are the same age.
Start
Please select confidence value, and older image
You have
30
comparisons to do.
Submitting your results, please wait......
Low confidence
Middle confidence
High confidence
Left image is older
Equal Age
Right is older


相关概念
NP-hard（non-deterministic polynomial-time hard）
- P：能在多项式时间内解决
- NP：不能在多项式时间内解决或不确定能不能在多项式时间内解决，但一旦你找到一个解，只需要多项式时间去验证这个解是正确的
- NP-hard：如果一个问题是NP-hard，意味着可以将任意NP问题化约到这个问题。如果可以解这个问题，那么可以轻松地解任意NP问题。
- NPC：NP完全问题，所有NP问题在多项式时间内都能化约（Reducibility）到某一NP问题，这一NP问题就是NPC问题，即解决了此NPC问题，所有NP问题也都解决了。
资料原文
These refer to how long it takes a program to run. Problems in class P can be solved with algorithms that run in polynomial time.
Say you have an algorithm that finds the smallest integer in an array. One way to do this is by iterating over all the integers of the array and keeping track of the smallest number you've seen up to that point. Every time you look at an element, you compare it to the current minimum, and if it's smaller, you update the minimum.
How long does this take? Let's say there are n elements in the array. For every element the algorithm has to perform a constant number of operations. Therefore we can say that the algorithm runs in O(n) time, or that the runtime is a linear function of how many elements are in the array. So this algorithm runs in linear time.
You can also have algorithms that run in quadratic time (O(n^2)), exponential time (O(2^n)), or even logarithmic time (O(log n)). Binary search (on a balanced tree) runs in logarithmic time because the height of the binary search tree is a logarithmic function of the number of elements in the tree.
If the running time is some polynomial function of the size of the input, for instance if the algorithm runs in linear time or quadratic time or cubic time, then we say the algorithm runs in polynomial time and the problem it solves is in class P.
NP
Now there are a lot of programs that don't (necessarily) run in polynomial time on a regular computer, but do run in polynomial time on a nondeterministic Turing machine. These programs solve problems in NP, which stands for nondeterministic polynomial time. A nondeterministic Turing machine can do everything a regular computer can and more. This means all problems in P are also in NP.
An equivalent way to define NP is by pointing to the problems that can be verified in polynomial time. This means there is not necessarily a polynomial-time way to find a solution, but once you have a solution it only takes polynomial time to verify that it is correct.
Some people think P = NP, which means any problem that can be verified in polynomial time can also be solved in polynomial time and vice versa. If they could prove this, it would revolutionize computer science because people would be able to construct faster algorithms for a lot of important problems.
NP-hard
What does NP-hard mean? A lot of times you can solve a problem by reducing it to a different problem. I can reduce Problem B to Problem A if, given a solution to Problem A, I can easily construct a solution to Problem B. (In this case, "easily" means "in polynomial time.")
If a problem is NP-hard, this means I can reduce any problem in NP to that problem. This means if I can solve that problem, I can easily solve any problem in NP. If we could solve an NP-hard problem in polynomial time, this would prove P = NP.
NP-complete
A problem is NP-complete if the problem is both
- NP-hard, and
- in NP.


This version of Zen-Rails is not optimized. It may be slow.
Very Rough Notes
JavaScript
Design
Features
Tests
Unit Tests
Demo of Proxy-Assisted Loading of a
Web Page Snapshot into an Iframe
(as a "Transclusion")
Note: This demo won't work without special assistance from the web server to overcome the single-domain policy of web browsers.
Experiment with State Machine


LZW Compressor¶
-
class
lzw3.compressor.
LZWCompressorHelper
(recursive: bool, verbose: bool, time: bool, keep: bool, force: bool)¶ An helper that invoke LZWCompressor.compress() and handles some more logic.
-
__init__
(recursive: bool, verbose: bool, time: bool, keep: bool, force: bool)¶ Initializes this helper.
Parameters: - recursive (bool) – whether directories should be entered recursively
- verbose (bool) – whether output basic info to standard output
- time (bool) – whether print the time of each task executed (is taken into consideration only if verbose is true)
- keep (bool) – whether keep original files after the task
- force (bool) – whether force the action (for compression means to always keep the output file)
-
handle
(files: List[str])¶ Handles the file list using the settings provided to this helper.
Parameters: files ( list
ofstr
) – list of files (or directories) to handle
-
-
class
lzw3.compressor.
LZWCompressor
¶ Compressor of regular files that use LZW algorithm.
-
compress
(in_file_path: str, out_file_path: str) → bool¶ Compresses the given input file to the output file.
Parameters: - in_file_path (str) – the path of the (regular) file to compress
- out_file_path (str) – the path of the file that will contain the compressed content of the input file
Returns: whether the file (exists and) has been compressed successfully
Return type: bool
-
LZW Decompressor¶
-
class
lzw3.decompressor.
LZWDecompressorHelper
(recursive: bool, verbose: bool, time: bool, keep: bool, force: bool)¶ An helper that invoke LZWDecompressor.decompress() and handles some more logic.
-
__init__
(recursive: bool, verbose: bool, time: bool, keep: bool, force: bool)¶ Initializes this helper.
Parameters: - recursive (bool) – whether directories should be entered recursively
- verbose (bool) – whether output basic info to standard output
- time (bool) – whether print the time of each task executed (is taken into consideration only if verbose is true)
- keep (bool) – whether keep original files after the task
- force (bool) – whether force the action (for compression means to always keep the output file)
-
handle
(files: List[str])¶ Handles the file list using the settings provided to this helper.
Parameters: files ( list
ofstr
) – list of files (or directories) to handle
-
-
class
lzw3.decompressor.
LZWDecompressor
¶ Decompressor of regular files that use LZW algorithm.
-
decompress
(in_file_path: str, out_file_path: str) → bool¶ Decompresses the given input file to the output file
Parameters: - in_file_path (str) – the path of the compressed file
- out_file_path (str) – the path of the file that will contain the uncompressed content of the input file
Returns: whether the file (exists and) has been decompressed successfully
Return type: bool
-


Watch this lock picker remove an inventory control tag in one second
by Mark FrauenfelderIt's frustrating to buy an article of clothing from a store, then get home and discover that the ink-filled inventory control tag is still attached. This happened to the Lock Picking Lawyer, but instead of wasting a lot of time returning to the store, he was able to safely remove the tag at home in a fraction of a second by holding a neodymium magnet against it.
Image: YouTube


|
Or you can copy-paste the link directly into your browser's URL bar:
{{ protocol }}://{{ site.domain }}{{ url }}
Happy dancing!
The Dancerfly Team
P.S. If you didn't register for Dancerfly or believe this message was intended for someone else, please email<EMAIL_ADDRESS>|


Copyright © 2010 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark, and document use rules apply.
Syntax tests syntax-sparql1
This page describes W3C SPARQL Working Group's SPARQL1.0 test suite.
The test manifests and entries are built automatically from manifest.ttl using a Rake task. Tests may be contributed via pull request to https://github.com/w3c/rdf-tests with suitable changes to the manifest.ttl and referenced files.
Distributed under both the W3C Test Suite License and the W3C 3-clause BSD License. To contribute to a W3C Test Suite, see the policies and contribution forms.
 COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE DOCUMENT OR THE PERFORMANCE OR IMPLEMENTATION OF THE CONTENTS THEREOF.


Sometimes, it can be annoying to see uninteresting, unversioned items—for example, files that result from a program's compilation. The Subversion global-ignores option is a whitespace-delimited list of names of files and directories that Subversion should not display unless they are versioned. The default values are: *.o *.lo *.la *.al .libs *.so *.so.[0-9]* *.a *.pyc *.pyo *.rej *~ #*# .#* .*.swp .DS_Store.
If you want to change this default list follow these steps:
Note: these settings only apply to your user account
More information on the global-config file and its settings can be found here. More information on using fine grained ignores in Versions can be found here.


Our compone is called tales.
Where are found in Mountainview estate
We are young developers.
our comone makes weabsigt other componies.


{{left_sidebar_enabled,right_sidebar_enabled=True,False}} {{extend 'layout.html'}} {{if viewtext <>'':}}
{{=viewtext}}
{{pass}}{{=MARKMIN(quest['questiontext'])}}
Users have resolved that the correct answer is:
{{=quest['correctanstext']}}
{{pass}}The analysis of all answers is shown below.
| {{for item in lstanswers:}} | {{=item}} | {{pass}}
|---|---|
| {{for item in lstnumanswers:}} | {{=item}} | {{pass}}
This question has been answered {{=quest['totanswers']}} times. {{=numpass}} users passed on this question. The current category is {{=quest['category']}}.
{{if quest['status'] == 'Resolved':}} {{if quest['answerreasons'] <> '':}}This question is resolved - if you think the answer is wrong you may wish to challenge
Reason:
{{else:}}
This question is currently {{=quest['status']}}. You don't have the option to challenge or agree and disagree at present because there is no resolved answer.
{{pass}}Here is how you and other people have rated the urgency and importance of the question so far.
| Urgency | Importance | |
|---|---|---|
| Overall | ||
| You |
Here is how other people rated the urgency and importance of this question.
| Urgency | Importance | |
|---|---|---|
| Overall |


We have created this site as a repository for guides, documentation and more for our Blackboard developer community. Please feel free to reach us out at<EMAIL_ADDRESS>if you have any questions. Happy Coding!


Basics to Computer Vision Series
Images as Function
Images are generally associated with concepts of vision and perception. But in the field of computer vision it is important to understand that image can be represented as a function as well. An image can be represented as a function \(I(x, y)\) which gives the intensity represented by height of the bar for a given coordinate \(x\) and \(y\).
So basically, an image can be thought of as one of the following:
- a matrix of numbers
- pixel intensity as a function of coordinates
- output of a camera
Theoretically, an image can be modelled as a function \(f\) or \(I\) from \(\mathbb{R}^2 \to \mathbb{R}\) where \(f(x,y)\) gives the intensity or value at position \((x,y)\).
Practically, an image can be modelled over a rectangle with a finite range, given by:
Similarly, color images are three functions stacked together representing the three channels (i.e. often R, G and B), written as, vector-valued functions (i.e. every pixel is a vector of numbers),
Such as function can be generalized as,
Digital Images
Another important realization in the computer vision is the fact that images in a computer system are discrete images and not continuous ones like human eyes see, i.e. images in computer have a matrix representation with non-continuous intensity values between two adjacent pixel which might not be the case for the actual ground truth image it is capturing.
Discretization of the digital image is two fold:
- Sample the actual image onto a 2D space of a regular matrix
- Quantize the intensity values (as digital images do not take continuous values for intensities) to the nearest integer.
Such operations often will lead to loss of some information but if often minimal and can be worked with.
Loading and Exploring Image
% import image and display
img = imread('tree.jpg');
imshow(img);
% load the image package
pkg load image;
% size of 3 channel image
disp(size(img));
% red channel extraction
img_red = img(:, :, 1);
imshow(img_red);
plot(img_red(80, :));
% convert to grayscale
gry = rgb2gray(img);
% size and class of image
disp(size(img));
disp(class(img));
% extract intensities from image
disp(gry(50, 100));
plot(gry(50, :));
- Slicing a matrix is same as cropping.
% cropping image by slicing
disp(gry(101:103, 201:203));
- Multiplying a matrix with a scalar (i.e scaling an image) helps adjust the brightness, i.e. if scalar greater than 1, the image becomes brighter else it gets darker because pixel value 255 represents white and 0 represents black.
% change brightness
function result = scale(image, value)
result = image .* value;
endfunction
imshow(scale(img, 2));
imshow(scale(img, 0.5));
- Since images can be treated as functions and are represented as matrices, they can undergo matrix operations such as addition substraction.
% import test images
img_1 = imread('cycle.jpeg');
img_2 = imread('tree.jpg');
min_h = min(size(img_1)(1), size(img_2)(1));
min_w = min(size(img_1)(2), size(img_2)(2));
img_1 = img_1(1:min_h, 1:min_w, :);
img_2 = img_2(1:min_h, 1:min_w, :);
% add images
imshow(img_1 + img_2);
imshow(img_1./2 + img_2./2);
% difference of images
imshow(img_1 - img_2);
imshow(img_2 - img_1);
imshow(img_1 - img_2 + img_2 - img_1);
imshow(imabsdiff(img_1, img_2));
The default data type of image pixels in many environments (including octave and matlab) is 8-bit unsigned integer which has range [0, 255]. So special care must be taken during addition and subtraction because values can often go out of this range and be clipped at lower and higher limit.
- Alpha blending has roots in weighted addition of two images to maintain pixel limits within the range.
function result = blend(image_1, image_2, alpha)
result = alpha .* image_1 + (1-alpha) .* image_2;
endfunction
imshow(blend(img_1, img_2, 0.75));
imshow(blend(img_1, img_2, 0.25));
The value \(\alpha\) and \((1 - \alpha)\) ensure that the pixel values during alpha blending does not overflow the limits of pixel intensities.
Noise in Image
Noise in an image can be represented with a function, i.e.
where \(\eta\) is the noise.
Common types of noise functions are:
- Salt and pepper noise is random occurences of white and black pixels.
imshow(imnoise(gry, 'salt & pepper', 0.1));
- Impulse noise has random occurences of white pixels only.
- Guassian noise has variations in intensity drawn from a Guassian normal distribution.
imshow(imnoise(gry, 'gaussian'));
noise = randn(size(gry)) .* 200;
imshow(gry + noise);
It is possible to check that the values produced by randn
function follow a normal distribution by plotting the values produced by the function.
% plotting randn
noise = randn([1, 1000000]);
[n, x] = hist(noise, linspace(-5, 5, 50));
plot(x, n);
title('plot of randn function');
xlabel('x');
ylabel('n');
Filtering
Noise filtering is the process of eliminating or reducing the effect of noise from an image.
- Moving Average Filter or mean filter is one of the basic filtering techniques that tries to smooth a noisy image by means of averaging values over a window in the image. as the window size increases the smoothness of the curve will increase. This generally does not mean that the quality of the image will be improved as it can cause a blurring effect.
This averaging is based on the following assumptions:
- The value of a pixel at position must be similar to the ones nearby, surrounding it.
- The noise added to each pixel is independent of other noise values and hence would average to zero.
Since noise is basically an addition of a noise function to the image function, it can be argued that it is possible to remove noise by performing the additive inverse, i.e. subtract noise function and hence retrieve the original image. But the fallacy in such an argument lies in the fact that the noise functions are generally not reproducible and would not have a standard form associated with them. They might have a standard statistical form such as following a given probabilistic distribution.
Additive noise may also lead to loss of information if the value of pixels is scaled beyond the limits of the image pixel range.
Effect of moving average filter can be seen on a noisy sine wave using basic octave operations,
% moving average filters
f_3 = fspecial('average', 3);
f_10 = fspecial('average', 10);
% adding noise to sine wave
x = linspace(0, 20, 1000);
sin_x = sin(x);
noise = randn(size(sin_x)) .* 0.05;
sin_x_noisy = sin_x + noise;
% moving average filter on sin wave
sin_x_filtered_10 = imfilter(sin_x_noisy, f_10);
sin_x_filtered_3 = imfilter(sin_x_noisy, f_3);
plot(
x, sin_x_filtered_10, 'r',
x, sin_x_filtered_3, 'g',
x, sin_x_noisy, 'b'
);
title('effect of moving average filter on noisy sine wave');
xlabel('x');
ylabel('sin(x)');
legend (
'moving average with window size 10',
'moving average with window size 3',
'noisy sin(x)'
);
Similarly it can be applied to an image,
% import library
pkg load image;
img = imread('tree.jpg');
img = rgb2gray(img);
imshow(img);
% adding noise to image
sigma = 20;
noise = randn(size(img)) .* sigma;
img_noisy = img + noise;
imshow(img_noisy);
% moving average filter on image
img_filtered_3 = imfilter(img_noisy, f_3);
img_filtered_10 = imfilter(img_noisy, f_10);
x = linspace(100, 200, 101);
plot(
x, img_filtered_10(10, 100:200), 'r',
x, img_filtered_3(10, 100:200), 'g',
x, img_noisy(10, 100:200), 'b'
);
title('plot over column range [100, 200] for row 10');
xlabel('column');
ylabel('pixel intensity');
legend (
'moving average with window size 10',
'moving average with window size 3',
'noisy image'
);
w = size(img)(2);
x = linspace(0, w, w);
plot(
x, img_filtered_10(100, :), '+',
x, img_filtered_3(100, :), '.',
x, img_noisy(100, :), '*'
);
title('plot for row 100');
xlabel('column');
ylabel('pixel intensity');
legend (
'moving average with window size 10',
'moving average with window size 3',
'noisy image'
);
- Weighted Moving Average takes the assumption a step further than the moving average, positing that if a pixel is similar to nearby pixels then it should be more dependent on the nearer ones than on the farther ones. This information is encoded as weighted average for such filtering.
Effect of weighted moving average vs that of moving average can be seen below,
% weighted moving average for 1D
% assuming weights to be an odd sized vector
function result = weighted_moving_average(series, weights)
size_weights = size(weights)(2);
size_series = size(series)(2);
padding = zeros(1, size_weights/2);
size_padding = size(padding)(2);
series_padded = [padding, series, padding];
for idx = (size_padding + 1) : (size_series + size_padding)
series(idx-size_padding) = mean(
series_padded(idx-size_padding: idx-size_padding+size_weights-1)
./sum(weights)
.*weights);
endfor
result = series;
endfunction
% weighted moving average over a random vector
n = 3;
x = linspace(1, n, n*10);
sin_x = sin(x);
noise = randn(1, n*10) .* 0.1;
sin_x = noise + sin_x;
% uniform weights
weights = [1, 1, 1, 1, 1];
sin_x_mov_avg = weighted_moving_average(sin_x, weights);
% center biased weights
weights = [1, 2, 4, 2, 1];
sin_x_wgt_avg = weighted_moving_average(sin_x, weights);
plot(
x, sin_x_mov_avg .* 5, 'r',
x, sin_x_wgt_avg .* 5, 'b',
x, sin_x, 'g'
);
title('moving average vs weighted moving average');
xlabel('x');
ylabel('sin(x)');
legend('moving average', 'weighted moving average', 'noisy sin(x)');
The weight masks generally used are odd sized, as this makes the mask centred around the central pixel. Also, the results are divided by the sum of the weights to scale the results back to one.
The advantage of weighted moving average over normal moving average can be seen in Fig. 5. In region A and B it is clear that while the data (green plot) and weighted moving average (blue plot) are moving in one direction the normal moving average (red plot) is deviating in the other direction. This is usually becuase the normal moving average gives excessive importance to farther off pixels and hence would not catch sudden trend shifts accurately.
Correlation and Cross Correlation Filtering
Filtering in 2D is very similar to the filtering explained in the section above for the 1D filters on noisy signals. The only point of difference lies in the dimensions of the filter kernel i.e. in 2D filtering the filters are 2D. But the octave code for 2D filtering remains the same as shown below using fspecial
function.
% function to plot with labels
function plot_with_labels(matrix, color='white')
size_x = size(matrix, 1);
size_y = size(matrix, 2);
imagesc(matrix);
hold on;
[X Y] = meshgrid(1:size_x, 1:size_y);
string = mat2cell(transpose(matrix), ones(size_x, 1), ones(1, size_y));
text(
Y(:)-.45,X(:)+.15,
string,
'HorizontalAlignment','left',
'VerticalAlignment', 'middle',
'color', color,
'fontsize', 12);
grid_x = .5:1:(size_x + .5);
grid_y = .5:1:(size_y + .5);
grid1 = [grid_x;grid_y];
grid2 = repmat([.5;size_x + .5],1,length(grid_x));
plot(grid1,grid2,'k');
plot(grid2,grid1,'k');
endfunction
% moving average in 2D
img = zeros(10, 10);
img(3:7, 4:8) = 90;
img(6, 5) = 0;
img(9, 3) = 90;
f_3 = fspecial('average', 3);
f_5 = fspecial('average', 5);
subplot(3, 1, 1);
plot_with_labels(img);
title('original noisy image');
img_3 = imfilter(img, f_3);
subplot(3, 1, 2);
plot_with_labels(img_3);
title('image after average filter with window size 3');
img_5 = imfilter(img, f_5);
subplot(3, 1, 3);
plot_with_labels(img_5);
title('image after average filter with window size 5');
Mathematically, the operation performed in the above code is called correlation filtering with uniform weights. For an averaging window of size \((2k+1 * 2k+1)\) (odd sized window explained in last section), it is given by,
where \(F\) is the image we start with and \(G\) is the final after correlation filtering.
Similarly, one can implement correlation filtering with non-uniform weights, called cross correlation filtering, given by,
where \(G\) is the cross-correlation of \(H\) with \(F\) denoted by
where \(H\) is the matrix of linear weights, also called kernel, mask, or coefficient.
The kernel mentioned here have a slight relation with the machine learning kernels but are entirely different things and hence generally dealt with as seperate topics.
Generally in image processing the average filtering is not used as they are not smooth in magnitude transitions and this is where cross cross-correlation filtering (eg. guassian filter) proves to be advantageuous.
The smoothness of a given filter being applied to an image can be seen from the surface plots and the corresponding effect on the image of a dot as shown below,
% smoothness of filters
f_average = fspecial('average', 2);
f_smooth = fspecial('gaussian', 7, 1);
img = zeros(11, 11);
img(6,6) = 90;
img_average = imfilter(img, f_average);
img_smooth = imfilter(img, f_smooth);
subplot(2, 2, 1);
surf(f_average);
title('surface plot of average filter');
subplot(2, 2, 2);
surf(f_smooth);
title('surface plot of average filter');
subplot(2, 2, 3);
imagesc(img_average);
title('image after average filtering of a dot');
subplot(2, 2, 4);
imagesc(img_smooth);
title('image after guassian filtering of a dot');
Gaussian Filter
The isotropic (i.e. circularly symmetrical) Guassian function given by,
where sigma is the standard deviation of the function determining the spread of the plot. The effect of \(\sigma\) on the plot can be seen in the plot below.
For more on guassian or normal distribution read Normal Distribution
% comparison of sigma
f_gaussian_10 = fspecial('gaussian', 100, 10);
f_gaussian_20 = fspecial('gaussian', 100, 20);
subplot(2, 1, 1);
surf(f_gaussian_10);
title('plot with sigma = 10');
subplot(2, 1, 2);
surf(f_gaussian_20);
title('plot with sigma = 20');
For a given filter size one can vary \(\sigma\) to change the mask or the kernel properties. The bigger the value of \(\sigma\) is the more the blur.
It can be seen from \eqref{7} that the function sigma depends on a single parameter \(\sigma\) that determines the spread of the plot. But, in actual programming, the filter would be represented by a matrix and hence has two properties, namely, size of the matrix and the size of the \(\sigma\).
So one can have different \(\sigma\) within same size of matrix (filter size) as shown in fig 8. The variance (\(\sigma^2\)) or standard deviation (\(\sigma\)) determines the amount of smoothing. The two filters in Fig. 8 have same size but different variance and hence different amount of smoothing.
Similarly, one can have different size matrices (filter size) for the same size of \(\sigma\) (kernel size) as in the plot below.
% same sigma in varying size matrix
f_gaussian_50 = fspecial('gaussian', 50, 10);
f_gaussian_20 = fspecial('gaussian', 20, 10);
subplot(2, 1, 1);
surf(f_gaussian_10);
title('plot with matrix side 50');
subplot(2, 1, 2);
surf(f_gaussian_20);
title('plot with matrix side 20');
Among the two, filter of size 50 would work better because it is more smooth among the two.
The Two Sigmas
There are two sigma’s discussed above. One is the intensity of noise and the other is standard deviation of the gaussian filter. The sigma in the intensity of the noise determines the amount of noise added to an image while the sigma of gaussian filter determines the amount of smoothing that occurs on applying the sigma. The two are different that should not be confused.
The reason they are both called sigma is because they both use the normal distribution. The plot of noise signals normal distribution can be seen in Fig. 1 (normal distribution over intensity) and similarly the plot of normal distribution of filtering kernel can be seen in Fig. 9 (isotropic normal distribution in space).
The effect of both the sigmas can be seen in the plot below.
Hence, it is important to understand the difference between the two sigma’s which are generally clear from the context but often create confusion.


The purpose of Adapter.relax method is to make sure that the uiScroll relaxes and there are no internal processes working at the moment we need to run some logic. Basically, it may be treated as a shortcut for the following approach, which is presented on "Is loading" tab:
{{isLoadingSample}}
The Adapter.relax method accepts 1 optional argument, it is a callback that allow to run necessary logic right before resolving "relax" promise. This might be helpful if we don't want to wait until the end of the call stack. The "Relax cb" tab shows the difference between "await" and "callback" approaches.
This sample is quite artificial, because for 2 manual operations (remove and insert) the second one can be done safely by using Return value API, which is a part of each Adapter method. This approach is demonstrated on the last tab "Return".
But the point is that the first manual operation also might require safe call. If we have a chance that there are some pending processes at the moment we are going to run the Adapter method, then we should wait until these processes are done. The "Is loading" approach is about it. But having the "Relax" shortcut we may make our life easier.
{{relaxSample}}


{% block stylesheets %}{% endblock stylesheets %}
{% include 'includes/navigation.html' %}
logic
Welcome to Logic! This is a passion project (currently in beta) by the co-founders of N1 Esports, designed to provide the best content, resources, and tools for casual FPS gamers looking to improve at their own pace.
Why We Started This Project
Best New Videos
Staff Picks


Our Story
We are Robots Squad group, who met online and worked together to design, create and produce this website that we are proud of.
Our Team
Tell Us ...
We are Robots Squad group, who met online and worked together to design, create and produce this website that we are proud of.
Tell Us ...


Equation of time
Cardinal day of the year
Julian day number
Sun's apparent longitude
Sun's declination


|
|
Calibration CT Sensor Current |
1 |
3 years 36 weeks ago by andre.luiz1987 |
3 years 36 weeks ago by Robert Wall |
|
|
Calibration issues |
2 |
3 years 15 weeks ago by Guest |
3 years 15 weeks ago by Robert Wall |
|
|
Calibration techniques |
7 |
2 years 28 weeks ago by Guest |
2 years 28 weeks ago by Guest |
|
|
Calibration theory |
1 |
4 years 46 weeks ago by Guest |
4 years 45 weeks ago by Robert Wall |
|
|
Calibration Values for my CT |
1 |
2 years 5 weeks ago by bbroge |
2 years 5 weeks ago by Robert Wall |
|
|
Callibration |
3 |
5 years 15 weeks ago by Guest |
5 years 15 weeks ago by Guest |
|
|
CalVref |
3 |
3 years 1 day ago by fmj1988 |
2 years 2 weeks ago by Robert Wall |
|
|
Can anyone help with my project. Weather station integration. |
1 |
5 years 2 weeks ago by nz.mike.christiansen |
5 years 1 week ago by glyn.hudson |
|
|
Can emonTx arduino software handle 3 AC and 3 CT inputs? |
8 |
2 years 5 weeks ago by KWells |
2 years 5 weeks ago by KWells |
|
|
Can I locate the RF antenna away from the emonTx? |
5 |
1 year 19 weeks ago by crispin |
1 year 19 weeks ago by Bill Thomson |
|
|
Can I plugin the + EmonTX Shield into the NanodeRF SMT 868Mhz (no you can't) |
2 |
3 years 23 weeks ago by Wxll |
3 years 22 weeks ago by Robert Wall |
|
|
Can i use one AC power adapter for [Measuring AC Voltage and power supply for electric circuits] at the same time |
12 |
1 year 26 weeks ago by tinamore |
1 year 26 weeks ago by Robert Wall |
|
|
Can I use CR9580-20 (CT) as alternative for SCT013? |
4 |
47 weeks 3 days ago by rseshadr |
47 weeks 3 days ago by rseshadr |
|
|
Can I use the emonpi raspberry add-on as standalone |
2 |
1 year 3 weeks ago by cadrev |
1 year 1 week ago by cadrev |
|
|
Can Oregon Scientific rain gauge radio transmission be received? |
12 |
3 years 38 weeks ago by Ian Eagland |
3 years 24 weeks ago by Mattia Rossi |
|
|
Can RFμ-328-BARE be replaced by XRF module? |
0 |
2 years 2 weeks ago by ShaneLong |
n/a |
|
|
Can someone program my EmonGLCD chip? |
4 |
1 year 1 week ago by ChannelZ |
44 weeks 4 days ago by Robert Wall |
|
|
Can the emonTX v2.2 be powered by the same 9V ac adapter split to provide a 5V DC input |
5 |
1 year 40 weeks ago by bruce_miranda |
1 year 40 weeks ago by Robert Wall |
|
|
Can the Pi with enonbase work with a wifi dongle? |
6 |
3 years 25 weeks ago by noworries |
3 years 11 weeks ago by bernamorillo |
|
|
Can use one CT simultaneously to measure Volts and Current ? |
3 |
1 year 35 weeks ago by tinamore |
1 year 35 weeks ago by tinamore |
|
|
Can we make Emonbase with three moudles: Arduino UNO + emonTx Shield + Arduino Ethernet Shield ? |
2 |
3 years 36 weeks ago by Guest |
3 years 36 weeks ago by Guest |
|
|
can't get emontx to report temp at 5 min interval |
11 |
3 years 30 weeks ago by boelle |
3 years 5 weeks ago by Guest |
|
|
Can't get WiFi to work on Raspberry Pi EmonBase |
11 |
3 years 15 weeks ago by Guest |
3 years 1 week ago by Jérôme |
|
|
cannot open .sch files (Eagle) |
2 |
2 years 27 weeks ago by ahhk |
2 years 27 weeks ago by ahhk |
|
|
Cant connect to MySQL server |
7 |
4 years 19 weeks ago by boxer_ian |
4 years 17 weeks ago by boxer_ian |
|
|
capacitor |
2 |
4 years 38 weeks ago by Guest |
4 years 37 weeks ago by Robert Wall |
|
|
Carbon dioxide measure |
2 |
2 years 27 weeks ago by EmilianoM |
2 years 27 weeks ago by Robert Wall |
|
|
Case for EmonTX and temp sensor wiring |
3 |
4 years 44 weeks ago by Guest |
4 years 44 weeks ago by glyn.hudson |
|
|
Certification |
6 |
3 years 22 weeks ago by Guest |
3 years 18 weeks ago by Aniol |
|
|
changing connectors on effergy ct clamps for use with tx shield |
5 |
4 years 12 weeks ago by carlvk |
4 years 12 weeks ago by carlvk |
|
|
Cheap current sensors |
37 |
4 years 33 weeks ago by Guest |
4 years 13 weeks ago by Robert Wall |
|
|
Checking status of mains feed to boiler |
28 |
3 years 40 weeks ago by manicmoddin |
3 years 35 weeks ago by Robert Wall |
|
|
clip CT installation |
9 |
3 years 24 weeks ago by Guest |
3 years 20 weeks ago by Guest |
|
|
CO2 Sensor mg-811 |
18 |
2 years 51 weeks ago by borpin123 |
2 years 26 weeks ago by bernamorillo |
|
|
Code to upload first? |
28 |
2 years 35 weeks ago by yhabib |
2 years 5 weeks ago by Robert Wall |
|
|
Comms protocol for emonTx/base/lcd |
5 |
4 years 40 weeks ago by stuart |
4 years 40 weeks ago by mharizanov |
|
|
Community application using emonTx Shield on Arduino Mega R3 |
9 |
2 years 22 weeks ago by brouwer |
2 years 12 weeks ago by sababennie |
|
|
Compatible hardware |
1 |
2 years 15 weeks ago by Guest |
2 years 15 weeks ago by jon-ecm |
|
|
Complain about my Pre-Loaded Raspberry Pi Gateway 4GB SD card |
2 |
2 years 19 weeks ago by deploy |
2 years 19 weeks ago by TrystanLea |
|
|
Components for TXv3 |
0 |
2 years 11 weeks ago by Guest |
n/a |
|
|
Comprehensive Component List? |
8 |
4 years 34 weeks ago by seannation |
4 years 34 weeks ago by seannation |
|
|
Concurrent CT and Pulse inputs on EmonTX (v3) |
2 |
2 years 45 weeks ago by andym2 |
2 years 45 weeks ago by dBC |
|
|
confused with code calibration SCT-013 |
4 |
3 years 38 weeks ago by andre.luiz1987 |
3 years 38 weeks ago by Robert Wall |
|
|
Confusion over the different hardware modules |
2 |
1 year 11 weeks ago by Heathy65 |
1 year 11 weeks ago by pb66 |
|
|
Connecting a RFM12B to a PC? |
1 |
3 years 41 weeks ago by Guest |
3 years 41 weeks ago by MartinR |
|
|
Connecting an RFM12Pi to raspberry pi via serial(just for education purposes) |
2 |
1 year 22 weeks ago by chuayq |
1 year 22 weeks ago by chuayq |
|
|
Connecting CT Sensors directly to arduino |
7 |
3 years 19 weeks ago by hmaggo92 |
3 years 19 weeks ago by hmaggo92 |
|
|
Connecting emonTx via serial |
4 |
1 year 30 weeks ago by baldockery |
1 year 30 weeks ago by Robert Wall |
|
|
Connecting every breaker on a panel? |
2 |
1 year 32 weeks ago by Guest |
1 year 32 weeks ago by JD |
|
|
connecting the sensors |
2 |
5 years 42 weeks ago by Guest |
5 years 42 weeks ago by Guest |


| 548 | (A) | that the bestis one bakkes owte of br borowe ledde |
| 550 | (C) | That þe bestes on bakke . out of þe cyte ledde |
| 544 | (D) | þat þe bestis on bakkis out of borow leditħ |
| 536 | (E) | þat þe beestes on here bak . owt fro towne beryn |
| (Ex) | ---- no text ---- | |
| 565 | (L) | þat þe bestes on here bake out of burwe ladden |
| (P) | ---- no text ---- | |
| 543 | (U) | That the beestes on her bak / out of burgħ ladde |
| (V) | ---- no text ---- |


Version 0.01
Date: 2017-03-09
This is a collection of sample programs, job scripts, and input files to help new users become familiar with ODU's HPC environment. These samples are furnished by Old Dominion University (ODU) Research Computing Services and is primarily intended for ODU research computing users.
The samples include programs written in C++, Python, and R and their batch job scripts.
Sample scripts for SGE job scheduler for Turing HPC are also provided.
These sample scripts are provided in turing/<LANG>
subdirectory for
samples written in the <LANG>
languages.
Documentation and tutorials are provided in docs/
subdirectory.
All programs and documentations are meant to be examples for learning, as well as starting point to build your own programs/scripts. Feel free to copy and modify them to suit your need.
The first example of computational task to try out is the multiplication of two matrices. Please see the details in matmul1.html . In this task, you will learn about a batch job and how to submit a batch job.
Turing's documentation is located at https://docs.hpc.odu.edu/ .
If you have questions or comments regarding the sample code, please drop off an email at<EMAIL_ADDRESS>.


This example shows how to use an InfoBox as a map label. Like all true map labels, the InfoBox is attached to the "mapPane" so that it appears below markers and information windows. In this case, the InfoBox label is the word City Hall inside a rectangle. The 50px wide label is centered below the label's position by specifying a pixelOffset of (-25, 0).


Welcome to BIT150.
The first lecture will be on Thursday 9/28 at 10:00 in Hoagland 113.
Prior to class, please read the Schatz 2015 paper, and complete the BIT 150 Pre-Class Assessment - both available on the CANVAS site. The paper discusses the future of biological research over the next 20 years. Hopefully it will provide motivation for the content we’ll cover this quarter. The quiz is a refresher on biological concepts that we will build on throughout the course.
We look forward to meeting you on Thursday!
Dan and Shawn


Requiring the registrant to login gives them the option to come back at a later time and finish making payments (if enabled and applicable).


Money Play. Should Red double? If doubled, should White take?
pips Red=152 White=149
(CorrectAnswer= 0/0, ErrorScore= 0)
Red has very good structure while White does not and those two White checkers on Red's ace-point are stranded. White also has a blot subject to six hitting numbers. The race is in the balance.
The position is quite volatile so it cries out for a double. White has enough chances to venture a take but it is closer than you might think. Not doubling is a blunder. In my youth I used to give positions like this ‘one more roll' but not any more. Nowadays I like to win gammons with the cube on 2.
The position is quite volatile so it cries out for a double. White has enough chances to venture a take but it is closer than you might think. Not doubling is a blunder. In my youth I used to give positions like this ‘one more roll' but not any more. Nowadays I like to win gammons with the cube on 2.
1. Cubeful 2-ply 18/15(2) 13/10(2) Eq.: +0.675 0.685 0.114 0.001 - 0.315 0.048 0.000 2. Cubeful 2-ply 18/15(2) 6/3(2) Eq.: +0.599 (-0.076) 0.670 0.113 0.002 - 0.330 0.050 0.000 3. Cubeful 2-ply 13/7(2) Eq.: +0.575 (-0.099) 0.645 0.169 0.003 - 0.355 0.056 0.001 4. Cubeful 2-ply 18/15(2) 13/10 8/5 Eq.: +0.560 (-0.114) 0.653 0.118 0.002 - 0.347 0.052 0.000 5. Cubeful 2-ply 13/10(2) 6/3(2) Eq.: +0.531 (-0.144) 0.637 0.158 0.004 - 0.363 0.056 0.001


Duplicate/Merge Jobs
This allows the duplication of a single job, or merging of multiple jobs into a single job. Note: this can be done across Record Groups.
Why Duplicate a Job?
- By duplicating a job from another Record Group, this effectively copies a job from another Record Group to your current one. This might be helpful for publishing a job under a different OAI set.
- When duplicating a job, a user may run different validations and/or use a different mapper for ElasticSearch.
Why Merge jobs?
- In the even an ad hoc harvest of records occurs, perhaps for a small subset or a static harvest, this would allow merging those records with a larger group of records for analysis and publishing.


`
Controls
1
Actions
2
Background
Transform
3
Figure
4
Hair
Transform
Curve
5
Head
Transform
6
Eyebrows
Transform
Curve
7
Eyes
Transform
8
Nose
Transform
Curve
9
Mouth
Transform
Curve


Ready for Github Pages
This setup is ready to work on Github:
- Using Jekyll as a pattern. Just
commit
andpush
. - Home page sections in _includes/sections/ folder.
- All stylesheet in Sass syntax, including Normalize.css features.
- Javascript modules and Babel presets. Just run
gulp
and start typing modern Javascript. - Siteleaf setup. Yes! You have a CMS. So tell your colleagues now.


A review by John Beachem
* * * * *
CAST Russell Crowe - Bud White Guy Pearce - Ed Exley Kim Basinger - Lynn Bracken Kevin Spacey - Jack Vincennes James Cromwell - Dudley Smith Danny DeVito - Sid Hudgeons
When this wonderful film was released, two things killed it at the box office. The fact that it had very little advertising, and that it was overshadowed by the lumbering monstrosity that was "Titanic". When masterpieces like this are so completely defeated, it shows the rather sad state of affairs Hollywood is in today.
The labyrinth plot is mainly about three cops. Ed Exley, who is a golden boy of the LA police; Bud White, who is a maverick cop, playing by his own rules to get justice; and Jack Vincennes, the celebrity cop who works with Sid Hudgeons from the tabloid "Hush Hush" to get callers that will put his picture on the front page. The three very different men are brought together by a shooting at an all night coffee shop which claims the lives of over a dozen people. Soon however, they are dragged through a maze of crimes ranging from prostitution to heroin running, which reach through all levels of power in LA.
This film has it all. An incredible script, wonderful music, perfect and sets and lighting effects, and some of the best acting I've seen in a long time. The script is truly amazing, managing to take what should be a messy, convoluted story and turning it into storytelling at its finest. Easy to follow, despite the many subplots and characters. The characters are all real people that are developed and defined to the point where the audience truly believes these were real people. The music, by Jerry Goldsmith is perfect for the film. Highlighting every scene and giving a great impression that this is really 50's LA
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Please do not reply to this email. To get in touch with us, click Contact Us
© ${CURRENT_YEAR} Company Ltd, All rights reserved - Together we make a difference.
Company info
You can change your notification settings from your personal profile settings.


{% extends "botanycollection/base.html" %} {% load static %} {% block content %}
Welcome to the UQ Archaeobotany Reference Collection (UQARC)
UQARC is an online reference collection aiming to provide easier access to fully described plant macrofossil reference specimens of wood, seeds, chaff, leaves and tubers.
UQARC has been developed primarily to provide the widely spread researchers of ancient plant use and environments in the Indo-Pacific region (including Australia) with a permanent and updateable collection of fossil reference material to help facilitate research. However, it has no geographical boundaries and in it can be found modern and ancient specimens from around the world.
UQARC allows user to search entries by species, family and specific identification criteria. Access to the reference collection is open to all under a creative commons license.
UQARC houses both images and text descriptions of plant specimens and acts as the database management tool for UQ’s archaeobotanical reference collections. While initially designed by staff and students of The University of Queensland, UQARC is a broader community resource and welcomes contributions to its archive. All contributions are peer-reviewed for compliance with UQARC’s data standards and contributors are acknowledged in UQARC entries.
For further details please read the instructions or contact the maintainers.


Booking Confirmation
Thank you for booking with Coachhire.com Please read the below information carefully.
Please ensure the details contained in this email are correct, particularly if you have requested specific features (PA system, toilet) and ensure special requirements are listed in the notes section. If there is a problem or discrepancy, please call us right away on 0203 397 4460.
You will receive your driver’s contact details prior to departure, for your convenience. You now have a confirmed booking with us which is subject to our terms and conditions.
If there is any payment due on your booking please advise us how you would like to settle the amount. Be advised that a payment will need to be made on your booking within 48 hours to secure your vehicle and quote. Failure to settle your balance by the due date may affect availability and will often require a new quotation.
Payment Methods
Payment can be made in the following ways:
- By debit/credit card - please call 0203 397 4460 or use the ‘Pay Now’ link in this email to
pay online. A small admin charge may apply.
- Bank transfer to Transport2 (UK) Ltd, Santander Account number 10 22 73 89
sort code 09-02-22
- By Cheque to Transport2 (UK) Ltd. 551 Fairlie Road, Slough, Berkshire, SL1 4PY. Please allow enough time for your cheque to clear before journey date - we recommend 10 working days. N.B. Please write the booking reference on the back of cheque.
- Please note that the vehicle type is for descriptive purposes only, a vehicle will be allocated to provide sufficient seats for the number of passengers and luggage as booked. No assumption should be made that a vehicle will have capacity for additional passengers or luggage.
- Additional drops, pickups and/or other extras including driver accommodation/meals are NOT INCLUDED unless they are expressly stated in the notes section of your booking.
- All bookings are based on the 24 hour clock.
- Waiting times: all bookings include a 10 minute grace period. Any additional waiting time after 10 minutes will be charged at the prevailing rate.
- Amendments will be confirmed to you in writing. If you do not receive a confirmation following an amendment then your amendment has not been made.
- We cannot provide car seats for children.
- If your booking is for an airport pick up (e.g. Heathrow or Gatwick) you must make your way to the
coach park to meet your vehicle. The driver cannot leave the vehicle to collect the passengers from
the terminal building.
Our emergency contact number is 0203 397 4460 (option 2) 24 hours a day, 7 days a week.
All bookings are subject to our terms and conditions.
Thank you for choosing Coachhire.com


Justin Gensemer CS230 Assignment 2
Name:
Are you Male or Female:
Male
Female
What are you interested in:
Male
Female
What is your GPA:
Click me


This site aims to inform the viewer about the preliminary finds done during the archaeological Sacred Landscape survey project.
While the numbers that were used in the following visualisations is actual archaeological data, it has been purposely mangled by randomly deleting items. This has rendered any and all conclusions drawn from the visualisations on this site scientificly invalid. This was done to protect the hard work that has gone into the Sacred Landscape Project.
The Find types page shows the amount of certain types of archaeological finds per campaign year. Initialy it shows in the pie chart and accompaniïng legend the total amount of ceramic finds per year. Next to this the viewer can see the total amount of the different types of ceramic, represented in a histogram. When the user hovers over the piechart, the histogram changes to represent the different find ceramic type found in the year the user had highlighted. In this same way, the pie chart changes how many of a ceramic type was found over the different years. Lastly, the user can click on the switch above the histogram to change from displaying ceramic as a find category, to showing other find categories. At the bottom of the page an additional link is added to the complete preliminary report, which includes an appendix that shows what every abbreviation means.
The finds period page shows the relative dating of the finds. This visualisation has three elements. Firstly the horizontal bar chart. This shows on the x-axis a timeline, where every date visible corrisponds to a time period. The different bars show dating ranges of finds. Hovering over each bar will show its dating, both in abreviated periods and in dates AD, and the amount of finds with this dating range. The coloring of the bars indicates the amount of finds that per dating range, scaled logarithmicelly. This is shown in the bar at the bottom right of the graph, above which is a legend is shown that diplays to the user the meaning of each shorthand period signifiër and its dating range.


--- layout: default date: 30/06/2020 ---
Covers races from 30th April, 2020 — 18th June, 2020.
Last updated: {{ page.date | date: "%A, %B %e" }}
{% include standings.html riders=site.data.2020.series_3.crit teams=site.data.2020.series_3.critteam %} {% include datetime.html %}


Bank Account
Register a new Account:
Account Name:
ID Number or Passport Number:
E-mail:
Phone Number:
Initial Balance:
Confirm
Deposit or Withdraw Funds:
Deposit:
Withdraw:
Confirm
Current Balance:


A pleasant, attractive town with a busy fishing fleet. It is protected by off-lying islands.
Position 37°06.7'N, 07°37'W.
Manned GNR-Brigada Fiscal office next to the ferry jetty but Tavira is not a port of entry/exit and passports cannot be stamped.
The Capitania is located in the town, close west to the fishing quay.
Although the marina is full of local boats, there are moorings in very sheltered water, just off the charming, un-spoilt fishing village. They are under the control of the local Nautical Club.
Do not enter before half flood or at all if the swell is heavy. If the wind and/or swell are onshore, conditions become rougher on the ebb. Best time for either entering or for leaving is about one hour before high water.
Beware of fishing nets in the approach.
Anchor in about 3m SW of the jetties. Use an anchor light as fishing boats are active 24/7 and be sure to keep clear of the channel.
On shore, near the anchorage, there are restaurants, shops toilets etc. in a small community.
Last updated June 2010.


{% extends "boards/view.html" %} {% block page_title %}Delete commit {{commit.commit}} from repository {{repository.name}} of project {{board.name}}{% endblock %} {% block content %} {% include "repositories/commits/components/breadcrumbs.html" %}


Summoner Camoniell
What do you want now?  Oh, Eva! How can you be so cruel to me?...


Spring Boot Starters
We cannot deny that Spring has a learning curve but once you’re over the hump it is all about making the developer more efficient. It is designed to give a developer the ability to deliver software rapidly.
Spring Boot Starters
Spring Boot developers have created “starters” that are a slightly different concept from “seed projects”. A seed-project consists of a codebase that has been either generated or hand-coded to be the base of your application. They usually come in the form a github repository that you fork and start from. Spring Starters however are just like regular dependencies that you’d pull into your application and are kind of hidden from the rest of your program. These starters are built upon the auto-configuration feature discussed above in the Understanding the “Magic” of Spring section. Their code is ran when the application starts up and they will create Beans, start Web Servlets, establish connection pooling to a database, and do many more things.
Read: Spring Starters (spring.io)
Read: Intro to Spring Boot Starters (baeldung.com)
Spring Boot Executable “fat Jar”
A “fat Jar” or “Uber Jar” is a single Jar file that contains everything needed to run an application. The most powerful thing to realize here is that you can actually run a Spring Boot jar file and it will start up a Web Container from within the Jar file. You would normally have to deploy your application into a separate Webserver but with Spring Boot the Webserver is actually running within the Jar file!
This concept extends to other components like H2, Elasticsearch, Redis, etc. This is great for rapid development but eventually when a product matures we will change the architecture to be more production-like with external services. It’s all about getting up and running as fast as possible in the beginning.


Choose your training data and (optionally) development data.
| Number of classes | - |
|---|---|
| Number of instances | - |
| Number of instances | - |
|---|
| General learning rate (η ) | - |
|---|---|
| Frequency-aware learning rate (δ) | - |
| Regularization strength (λ) | - |
| Strength of feature hashing | - |
| Type of randomized rounding | 3.2 |
| Round | - |
|---|---|
| Performance (fps) | - |
| Performance (data per sec.) | - |
| Cumulative loss | - |
| Averaged loss | - |
| Cumulative loss on dev data | - |
| # of feaures | - |
| # of active feaures | - |
| Macro F1 | - |
| Estimated byte size of the resulting model | - |
| Total memory | - |
|---|---|
| Unused memory | - |