|
mlpack
1.0.12
|
The RASearch class: This class provides a generic manner to perform rank-approximate search via random-sampling. More...
Public Member Functions | |
| RASearch (const typename TreeType::Mat &referenceSet, const typename TreeType::Mat &querySet, const bool naive=false, const bool singleMode=false, const MetricType metric=MetricType()) | |
| Initialize the RASearch object, passing both a query and reference dataset. More... | |
| RASearch (const typename TreeType::Mat &referenceSet, const bool naive=false, const bool singleMode=false, const MetricType metric=MetricType()) | |
| Initialize the RASearch object, passing only one dataset, which is used as both the query and the reference dataset. More... | |
| RASearch (TreeType *referenceTree, TreeType *queryTree, const typename TreeType::Mat &referenceSet, const typename TreeType::Mat &querySet, const bool singleMode=false, const MetricType metric=MetricType()) | |
| Initialize the RASearch object with the given datasets and pre-constructed trees. More... | |
| RASearch (TreeType *referenceTree, const typename TreeType::Mat &referenceSet, const bool singleMode=false, const MetricType metric=MetricType()) | |
| Initialize the RASearch object with the given reference dataset and pre-constructed tree. More... | |
| ~RASearch () | |
| Delete the RASearch object. More... | |
| void | ResetQueryTree () |
| This function recursively resets the RAQueryStat of the queryTree to set 'bound' to WorstDistance and the 'numSamplesMade' to 0. More... | |
| void | Search (const size_t k, arma::Mat< size_t > &resultingNeighbors, arma::mat &distances, const double tau=5, const double alpha=0.95, const bool sampleAtLeaves=false, const bool firstLeafExact=false, const size_t singleSampleLimit=20) |
| Compute the rank approximate nearest neighbors and store the output in the given matrices. More... | |
| std::string | ToString () const |
Private Member Functions | |
| void | ResetRAQueryStat (TreeType *treeNode) |
Private Attributes | |
| bool | hasQuerySet |
| Indicates if a separate query set was passed. More... | |
| MetricType | metric |
| Instantiation of kernel. More... | |
| bool | naive |
| Indicates if naive random sampling on the set is being used. More... | |
| size_t | numberOfPrunes |
| Total number of pruned nodes during the neighbor search. More... | |
| std::vector< size_t > | oldFromNewQueries |
| Permutations of query points during tree building. More... | |
| std::vector< size_t > | oldFromNewReferences |
| Permutations of reference points during tree building. More... | |
| arma::mat | queryCopy |
| Copy of query dataset (if we need it, because tree building modifies it). More... | |
| const arma::mat & | querySet |
| Query dataset (may not be given). More... | |
| TreeType * | queryTree |
| Pointer to the root of the query tree (might not exist). More... | |
| arma::mat | referenceCopy |
| Copy of reference dataset (if we need it, because tree building modifies it). More... | |
| const arma::mat & | referenceSet |
| Reference dataset. More... | |
| TreeType * | referenceTree |
| Pointer to the root of the reference tree. More... | |
| bool | singleMode |
| Indicates if single-tree search is being used (opposed to dual-tree). More... | |
| bool | treeOwner |
| If true, this object created the trees and is responsible for them. More... | |
The RASearch class: This class provides a generic manner to perform rank-approximate search via random-sampling.
If the 'naive' option is chosen, this rank-approximate search will be done by randomly sampled from the whole set. If the 'naive' option is not chosen, the sampling is done in a stratified manner in the tree as mentioned in the algorithms in Figure 2 of the following paper:
{ram2009rank, title={{Rank-Approximate Nearest Neighbor Search: Retaining Meaning and Speed in High Dimensions}}, author={{Ram, P. and Lee, D. and Ouyang, H. and Gray, A. G.}}, booktitle={{Advances of Neural Information Processing Systems}}, year={2009} }
RASearch is currently known to not work with ball trees (#356).
| SortPolicy | The sort policy for distances; see NearestNeighborSort. |
| MetricType | The metric to use for computation. |
| TreeType | The tree type to use. |
Definition at line 63 of file ra_search.hpp.
| RASearch< SortPolicy, MetricType, TreeType >::RASearch | ( | const typename TreeType::Mat & | referenceSet, |
| const typename TreeType::Mat & | querySet, | ||
| const bool | naive = false , |
||
| const bool | singleMode = false , |
||
| const MetricType | metric = MetricType() |
||
| ) |
Initialize the RASearch object, passing both a query and reference dataset.
Optionally, perform the computation in naive mode or single-tree mode, and set the leaf size used for tree-building. An initialized distance metric can be given, for cases where the metric has internal data (i.e. the distance::MahalanobisDistance class).
This method will copy the matrices to internal copies, which are rearranged during tree-building. You can avoid this extra copy by pre-constructing the trees and passing them using a diferent constructor.
| referenceSet | Set of reference points. |
| querySet | Set of query points. |
| naive | If true, the rank-approximate search will be performed by directly sampling the whole set instead of using the stratified sampling on the tree. |
| singleMode | If true, single-tree search will be used (as opposed to dual-tree search). |
| leafSize | Leaf size for tree construction (ignored if tree is given). |
| metric | An optional instance of the MetricType class. |
| RASearch< SortPolicy, MetricType, TreeType >::RASearch | ( | const typename TreeType::Mat & | referenceSet, |
| const bool | naive = false , |
||
| const bool | singleMode = false , |
||
| const MetricType | metric = MetricType() |
||
| ) |
Initialize the RASearch object, passing only one dataset, which is used as both the query and the reference dataset.
Optionally, perform the computation in naive mode or single-tree mode, and set the leaf size used for tree-building. An initialized distance metric can be given, for cases where the metric has internal data (i.e. the distance::MahalanobisDistance class).
If naive mode is being used and a pre-built tree is given, it may not work: naive mode operates by building a one-node tree (the root node holds all the points). If that condition is not satisfied with the pre-built tree, then naive mode will not work.
| referenceSet | Set of reference points. |
| naive | If true, the rank-approximate search will be performed by directly sampling the whole set instead of using the stratified sampling on the tree. |
| singleMode | If true, single-tree search will be used (as opposed to dual-tree search). |
| leafSize | Leaf size for tree construction (ignored if tree is given). |
| metric | An optional instance of the MetricType class. |
| RASearch< SortPolicy, MetricType, TreeType >::RASearch | ( | TreeType * | referenceTree, |
| TreeType * | queryTree, | ||
| const typename TreeType::Mat & | referenceSet, | ||
| const typename TreeType::Mat & | querySet, | ||
| const bool | singleMode = false , |
||
| const MetricType | metric = MetricType() |
||
| ) |
Initialize the RASearch object with the given datasets and pre-constructed trees.
It is assumed that the points in referenceSet and querySet correspond to the points in referenceTree and queryTree, respectively. Optionally, choose to use single-tree mode. Naive mode is not available as an option for this constructor; instead, to run naive computation, construct a tree with all of the points in one leaf (i.e. leafSize = number of points). Additionally, an instantiated distance metric can be given, for cases where the distance metric holds data.
There is no copying of the data matrices in this constructor (because tree-building is not necessary), so this is the constructor to use when copies absolutely must be avoided.
| referenceTree | Pre-built tree for reference points. |
| queryTree | Pre-built tree for query points. |
| referenceSet | Set of reference points corresponding to referenceTree. |
| querySet | Set of query points corresponding to queryTree. |
| singleMode | Whether single-tree computation should be used (as opposed to dual-tree computation). |
| metric | Instantiated distance metric. |
| RASearch< SortPolicy, MetricType, TreeType >::RASearch | ( | TreeType * | referenceTree, |
| const typename TreeType::Mat & | referenceSet, | ||
| const bool | singleMode = false , |
||
| const MetricType | metric = MetricType() |
||
| ) |
Initialize the RASearch object with the given reference dataset and pre-constructed tree.
It is assumed that the points in referenceSet correspond to the points in referenceTree. Optionally, choose to use single-tree mode. Naive mode is not available as an option for this constructor; instead, to run naive computation, construct a tree with all the points in one leaf (i.e. leafSize = number of points). Additionally, an instantiated distance metric can be given, for the case where the distance metric holds data.
There is no copying of the data matrices in this constructor (because tree-building is not necessary), so this is the constructor to use when copies absolutely must be avoided.
| referenceTree | Pre-built tree for reference points. |
| referenceSet | Set of reference points corresponding to referenceTree. |
| singleMode | Whether single-tree computation should be used (as opposed to dual-tree computation). |
| metric | Instantiated distance metric. |
| RASearch< SortPolicy, MetricType, TreeType >::~RASearch | ( | ) |
Delete the RASearch object.
The tree is the only member we are responsible for deleting. The others will take care of themselves.
| void RASearch< SortPolicy, MetricType, TreeType >::ResetQueryTree | ( | ) |
This function recursively resets the RAQueryStat of the queryTree to set 'bound' to WorstDistance and the 'numSamplesMade' to 0.
This allows a user to perform multiple searches on the same pair of trees, possibly with different levels of approximation without requiring to build a new pair of trees for every new (approximate) search.
|
private |
| treeNode | The node of the tree whose RAQueryStat is reset and whose children are to be explored recursively. |
| void RASearch< SortPolicy, MetricType, TreeType >::Search | ( | const size_t | k, |
| arma::Mat< size_t > & | resultingNeighbors, | ||
| arma::mat & | distances, | ||
| const double | tau = 5 , |
||
| const double | alpha = 0.95 , |
||
| const bool | sampleAtLeaves = false , |
||
| const bool | firstLeafExact = false , |
||
| const size_t | singleSampleLimit = 20 |
||
| ) |
Compute the rank approximate nearest neighbors and store the output in the given matrices.
The matrices will be set to the size of n columns by k rows, where n is the number of points in the query dataset and k is the number of neighbors being searched for.
Note that tau, the rank-approximation parameter, specifies that we are looking for k neighbors with probability alpha of being in the top tau percent of nearest neighbors. So, as an example, if our dataset has 1000 points, and we want 5 nearest neighbors with 95% probability of being in the top 5% of nearest neighbors (or, the top 50 nearest neighbors), we set k = 5, tau = 5, and alpha = 0.95.
The method will fail (and issue a failure message) if the value of tau is too low: tau must be set such that the number of points in the corresponding percentile of the data is greater than k. Thus, if we choose tau = 0.1 with a dataset of 1000 points and k = 5, then we are attempting to choose 5 nearest neighbors out of the closest 1 point – this is invalid.
| k | Number of neighbors to search for. |
| resultingNeighbors | Matrix storing lists of neighbors for each query point. |
| distances | Matrix storing distances of neighbors for each query point. |
| tau | The rank-approximation in percentile of the data. The default value is 5%. |
| alpha | The desired success probability. The default value is 0.95. |
| sampleAtLeaves | Sample at leaves for faster but less accurate computation. This defaults to 'false'. |
| firstLeafExact | Traverse to the first leaf without approximation. This can ensure that the query definitely finds its (near) duplicate if there exists one. This defaults to 'false' for now. |
| singleSampleLimit | The limit on the largest node that can be approximated by sampling. This defaults to 20. |
| std::string RASearch< SortPolicy, MetricType, TreeType >::ToString | ( | ) | const |
|
private |
Indicates if a separate query set was passed.
Definition at line 271 of file ra_search.hpp.
|
private |
Instantiation of kernel.
Definition at line 279 of file ra_search.hpp.
|
private |
Indicates if naive random sampling on the set is being used.
Definition at line 274 of file ra_search.hpp.
|
private |
Total number of pruned nodes during the neighbor search.
Definition at line 287 of file ra_search.hpp.
|
private |
Permutations of query points during tree building.
Definition at line 284 of file ra_search.hpp.
|
private |
Permutations of reference points during tree building.
Definition at line 282 of file ra_search.hpp.
|
private |
Copy of query dataset (if we need it, because tree building modifies it).
Definition at line 256 of file ra_search.hpp.
|
private |
Query dataset (may not be given).
Definition at line 261 of file ra_search.hpp.
|
private |
Pointer to the root of the query tree (might not exist).
Definition at line 266 of file ra_search.hpp.
|
private |
Copy of reference dataset (if we need it, because tree building modifies it).
Definition at line 254 of file ra_search.hpp.
|
private |
Reference dataset.
Definition at line 259 of file ra_search.hpp.
|
private |
Pointer to the root of the reference tree.
Definition at line 264 of file ra_search.hpp.
|
private |
Indicates if single-tree search is being used (opposed to dual-tree).
Definition at line 276 of file ra_search.hpp.
|
private |
If true, this object created the trees and is responsible for them.
Definition at line 269 of file ra_search.hpp.


{{extend 'layout.html'}}
We started as an interesting project and developed StopStalk as a utility tool to support a generous cause of getting you better into Competitive Programming. We have been online since 2 years and received a great response from all the learners across the globe. To support the Hosting, SSL and Domain costs we are not inclined towards charging the users of the website for any of the service right now or putting Ads. As we scale with tremendous amount of submissions we cannot rely on free services and we have already migrated to standard services. Any amount would be highly appreciated :)
Please write to us once your transaction is complete for confirmation.


* Select an image file on your computer (image should be
JPEG/PNG format, 2500x2500 pixels maximum and 500x500 pixels minimum).
Please do not upload offensive images as children also play this game.
You can report abuse by sending an email to
<EMAIL_ADDRESS>You have not selected a file.
Your file has wrong format, should be JPEG or PNG.
Image size is bigger than allowed (2500x2500 pixels maximum).
Image size is smaller than allowed (500x500 pixels minimum).


Warns against binding to standard event attributes and properties (starting with 'on') in Angular templates.


Basingstoke, England
The Blue Plaque of Mrs Blunden
This plaque remembers a grave mistake that led to one local woman being buried alive.
by YoAdOThis entry is a stub
Help improve Atlas Obscura by expanding The Blue Plaque of Mrs Blunden with additional information or photos.
In 1674, Mrs. Blunden lived in Basingstoke along with her husband, a wealthy and respected merchant.
One evening while her husband was away trading in London, she was accidentally given a large quantity of poppy syrup, instead of her usual spirits. Shortly after drinking the concoction, Blunden fell unconscious. Her maids believed she was in a deep sleep, however, after a few days of waiting to see if she would come to, Blunden was declared dead by a physician.
The following evening her body was interred inside the family vault, not far from the Holy Ghost Grammar School. In the days following her burial, a pair of boys heard ghastly sounds coming from the vault. When other boys from the school had similar stories the coffin was exhumed.
Inside Mrs. Blunden was covered in bruises and self-inflicted wounds, leading many to believe that she was alive when buried and attempted to escape. Her body was then examined by three different doctor’s, at that point she was once again declared dead and placed back into the vault.
Today, a blue plaque found on a wall in the Holy Ghost cemetery remembers this medical blunder. It also indicates that the town was fined for negligence by Parliament.
Community Discussion
-
No Comments Yet
Start the discussion.
forum Visit our forums.
Sources
- Francis Joseph Baigent and James Elwin Millard, A History of the Ancient Town and Manor of Basingstoke
- https://www.findagrave.com/memorial/138274765/blunden
- https://www.google.com/amp/s/www.thevintagenews.com/2018/08/08/alice-blunden/amp/


No-one needs a visa to visit this island.
It is not usually possible to land except by helicopter as all the coasts are vertical rock or ice cliffs, although some climbers landed in February 2012 and reached the top of the glacier on the island.
Last updated April 2014.


CHECK-IN TO BECOME AN LiteBookyPRENEUR!
We offers a variety of options to freshers and students alike, which are aimed at helping you chart your career growth
We welcome professionals from different industries, walks of life and at various stages in their professional journeys to join us and contribute to our mission
If you believe in driving impact through technology, then LiteBooky is where you must be now! Our Technology team creates platforms that enable our services to be innovative, cutting-edge, first in the industry and efficient


Bubble Sort sorts its data by repeatedly comparing adjacent elements It swaps them should they be in the wrong order
Step 1: In an unsorted array of 5 elements, start with the first two elements and sort them in ascending order. (Compare the element to check which one is greater)
Step 2: Compare the second and third element to check which one is greater, and sort them in ascending order
Step 3: Compare the third and fourth element to check which one is greater, and sort them in ascending order
Step 4: Compare the fourth and fifth element to check which one is greater, and sort them in ascending order
Step 5: Repeat steps 1–5 until no more swaps are required.


A function that would accept a string parameter and output the longest word within the string
A function that accepts a number parameter and output if the number is prime or not
A form that has 1 input for hour. On submit, display equivalent minutes from the inputted hour.


Flask Changelog¶
Here you can see the full list of changes between each Flask release.
Version 0.10.1¶
(bugfix release, released on June 14th 2013)
- Fixed an issue where
|tojson
was not quoting single quotes which made the filter not work properly in HTML attributes. Now it’s possible to use that filter in single quoted attributes. This should make using that filter with angular.js easier. - Added support for byte strings back to the session system. This broke compatibility with the common case of people putting binary data for token verification into the session.
- Fixed an issue were registering the same method twice for the same endpoint would trigger an exception incorrectly.
Version 0.10¶
Released on June 13nd 2013, codename Limoncello.
- Changed default cookie serialization format from pickle to JSON to limit the impact an attacker can do if the secret key leaks. See Version 0.10 for more information.
- Added
template_test
methods in addition to the already existingtemplate_filter
method family. - Added
template_global
methods in addition to the already existingtemplate_filter
method family. - Set the content-length header for x-sendfile.
tojson
filter now does not escape script blocks in HTML5 parsers.tojson
used in templates is now safe by default due. This was allowed due to the different escaping behavior.- Flask will now raise an error if you attempt to register a new function on an already used endpoint.
- Added wrapper module around simplejson and added default serialization of datetime objects. This allows much easier customization of how JSON is handled by Flask or any Flask extension.
- Removed deprecated internal
flask.session
module alias. Useflask.sessions
instead to get the session module. This is not to be confused withflask.session
the session proxy. - Templates can now be rendered without request context. The behavior is
slightly different as the
request
,session
andg
objects will not be available and blueprint’s context processors are not called. - The config object is now available to the template as a real global and not through a context processor which makes it available even in imported templates by default.
- Added an option to generate non-ascii encoded JSON which should result
in less bytes being transmitted over the network. It’s disabled by
default to not cause confusion with existing libraries that might expect
flask.json.dumps
to return bytestrings by default. flask.g
is now stored on the app context instead of the request context.flask.g
now gained aget()
method for not erroring out on non existing items.flask.g
now can be used with thein
operator to see what’s defined and it now is iterable and will yield all attributes stored.flask.Flask.request_globals_class
got renamed toflask.Flask.app_ctx_globals_class
which is a better name to what it does since 0.10.- request, session and g are now also added as proxies to the template context which makes them available in imported templates. One has to be very careful with those though because usage outside of macros might cause caching.
- Flask will no longer invoke the wrong error handlers if a proxy exception is passed through.
- Added a workaround for chrome’s cookies in localhost not working as intended with domain names.
- Changed logic for picking defaults for cookie values from sessions to work better with Google Chrome.
- Added message_flashed signal that simplifies flashing testing.
- Added support for copying of request contexts for better working with greenlets.
- Removed custom JSON HTTP exception subclasses. If you were relying on them you can reintroduce them again yourself trivially. Using them however is strongly discouraged as the interface was flawed.
- Python requirements changed: requiring Python 2.6 or 2.7 now to prepare for Python 3.3 port.
- Changed how the teardown system is informed about exceptions. This is now more reliable in case something handles an exception halfway through the error handling process.
- Request context preservation in debug mode now keeps the exception information around which means that teardown handlers are able to distinguish error from success cases.
- Added the
JSONIFY_PRETTYPRINT_REGULAR
configuration variable. - Flask now orders JSON keys by default to not trash HTTP caches due to different hash seeds between different workers.
- Added appcontext_pushed and appcontext_popped signals.
- The builtin run method now takes the
SERVER_NAME
into account when picking the default port to run on. - Added flask.request.get_json() as a replacement for the old flask.request.json property.
Version 0.9¶
Released on July 1st 2012, codename Campari.
- The
flask.Request.on_json_loading_failed()
now returns a JSON formatted response by default. - The
flask.url_for()
function now can generate anchors to the generated links. - The
flask.url_for()
function now can also explicitly generate URL rules specific to a given HTTP method. - Logger now only returns the debug log setting if it was not set explicitly.
- Unregister a circular dependency between the WSGI environment and
the request object when shutting down the request. This means that
environ
werkzeug.request
will be None after the response was returned to the WSGI server but has the advantage that the garbage collector is not needed on CPython to tear down the request unless the user created circular dependencies themselves. - Session is now stored after callbacks so that if the session payload is stored in the session you can still modify it in an after request callback.
- The
flask.Flask
class will avoid importing the provided import name if it can (the required first parameter), to benefit tools which build Flask instances programmatically. The Flask class will fall back to using import on systems with custom module hooks, e.g. Google App Engine, or when the import name is inside a zip archive (usually a .egg) prior to Python 2.7. - Blueprints now have a decorator to add custom template filters application
wide,
flask.Blueprint.app_template_filter()
. - The Flask and Blueprint classes now have a non-decorator method for adding
custom template filters application wide,
flask.Flask.add_template_filter()
andflask.Blueprint.add_app_template_filter()
. - The
flask.get_flashed_messages()
function now allows rendering flashed message categories in separate blocks, through acategory_filter
argument. - The
flask.Flask.run()
method now accepts None for host and port arguments, using default values when None. This allows for calling run using configuration values, e.g.app.run(app.config.get('MYHOST'), app.config.get('MYPORT'))
, with proper behavior whether or not a config file is provided. - The
flask.render_template()
method now accepts a either an iterable of template names or a single template name. Previously, it only accepted a single template name. On an iterable, the first template found is rendered. - Added
flask.Flask.app_context()
which works very similar to the request context but only provides access to the current application. This also adds support for URL generation without an active request context. - View functions can now return a tuple with the first instance being an
instance of
flask.Response
. This allows for returningjsonify(error="error msg"), 400
from a view function. Flask
andBlueprint
now provide aget_send_file_max_age()
hook for subclasses to override behavior of serving static files from Flask when usingflask.Flask.send_static_file()
(used for the default static file handler) andsend_file()
. This hook is provided a filename, which for example allows changing cache controls by file extension. The default max-age for send_file and static files can be configured through a newSEND_FILE_MAX_AGE_DEFAULT
configuration variable, which is used in the default get_send_file_max_age implementation.- Fixed an assumption in sessions implementation which could break message flashing on sessions implementations which use external storage.
- Changed the behavior of tuple return values from functions. They are no longer arguments to the response object, they now have a defined meaning.
- Added
flask.Flask.request_globals_class
to allow a specific class to be used on creation of theg
instance of each request. - Added required_methods attribute to view functions to force-add methods on registration.
- Added
flask.after_this_request()
. - Added
flask.stream_with_context()
and the ability to push contexts multiple times without producing unexpected behavior.
Version 0.8.1¶
Bugfix release, released on July 1st 2012
- Fixed an issue with the undocumented flask.session module to not work properly on Python 2.5. It should not be used but did cause some problems for package managers.
Version 0.8¶
Released on September 29th 2011, codename Rakija
- Refactored session support into a session interface so that the implementation of the sessions can be changed without having to override the Flask class.
- Empty session cookies are now deleted properly automatically.
- View functions can now opt out of getting the automatic OPTIONS implementation.
- HTTP exceptions and Bad Request errors can now be trapped so that they show up normally in the traceback.
- Flask in debug mode is now detecting some common problems and tries to warn you about them.
- Flask in debug mode will now complain with an assertion error if a view was attached after the first request was handled. This gives earlier feedback when users forget to import view code ahead of time.
- Added the ability to register callbacks that are only triggered once at
the beginning of the first request. (
Flask.before_first_request()
) - Malformed JSON data will now trigger a bad request HTTP exception instead of a value error which usually would result in a 500 internal server error if not handled. This is a backwards incompatible change.
- Applications now not only have a root path where the resources and modules are located but also an instance path which is the designated place to drop files that are modified at runtime (uploads etc.). Also this is conceptionally only instance depending and outside version control so it’s the perfect place to put configuration files etc. For more information see Instance Folders.
- Added the
APPLICATION_ROOT
configuration variable. - Implemented
session_transaction()
to easily modify sessions from the test environment. - Refactored test client internally. The
APPLICATION_ROOT
configuration variable as well asSERVER_NAME
are now properly used by the test client as defaults. - Added
flask.views.View.decorators
to support simpler decorating of pluggable (class-based) views. - Fixed an issue where the test client if used with the “with” statement did not trigger the execution of the teardown handlers.
- Added finer control over the session cookie parameters.
- HEAD requests to a method view now automatically dispatch to the get method if no handler was implemented.
- Implemented the virtual
flask.ext
package to import extensions from. - The context preservation on exceptions is now an integral component of Flask itself and no longer of the test client. This cleaned up some internal logic and lowers the odds of runaway request contexts in unittests.
Version 0.7.3¶
Bugfix release, release date to be decided
- Fixed the Jinja2 environment’s list_templates method not returning the correct names when blueprints or modules were involved.
Version 0.7.2¶
Bugfix release, released on July 6th 2011
- Fixed an issue with URL processors not properly working on blueprints.
Version 0.7.1¶
Bugfix release, released on June 29th 2011
- Added missing future import that broke 2.5 compatibility.
- Fixed an infinite redirect issue with blueprints.
Version 0.7¶
Released on June 28th 2011, codename Grappa
- Added
make_default_options_response()
which can be used by subclasses to alter the default behavior for OPTIONS responses. - Unbound locals now raise a proper
RuntimeError
instead of anAttributeError
. - Mimetype guessing and etag support based on file objects is now
deprecated for
flask.send_file()
because it was unreliable. Pass filenames instead or attach your own etags and provide a proper mimetype by hand. - Static file handling for modules now requires the name of the static folder to be supplied explicitly. The previous autodetection was not reliable and caused issues on Google’s App Engine. Until 1.0 the old behavior will continue to work but issue dependency warnings.
- fixed a problem for Flask to run on jython.
- added a PROPAGATE_EXCEPTIONS configuration variable that can be used to flip the setting of exception propagation which previously was linked to DEBUG alone and is now linked to either DEBUG or TESTING.
- Flask no longer internally depends on rules being added through the add_url_rule function and can now also accept regular werkzeug rules added to the url map.
- Added an endpoint method to the flask application object which allows one to register a callback to an arbitrary endpoint with a decorator.
- Use Last-Modified for static file sending instead of Date which was incorrectly introduced in 0.6.
- Added create_jinja_loader to override the loader creation process.
- Implemented a silent flag for config.from_pyfile.
- Added teardown_request decorator, for functions that should run at the end of a request regardless of whether an exception occurred. Also the behavior for after_request was changed. It’s now no longer executed when an exception is raised. See Upgrading to new Teardown Handling
- Implemented
flask.has_request_context()
- Deprecated init_jinja_globals. Override the
create_jinja_environment()
method instead to achieve the same functionality. - Added
flask.safe_join()
- The automatic JSON request data unpacking now looks at the charset mimetype parameter.
- Don’t modify the session on
flask.get_flashed_messages()
if there are no messages in the session. - before_request handlers are now able to abort requests with errors.
- it is not possible to define user exception handlers. That way you can provide custom error messages from a central hub for certain errors that might occur during request processing (for instance database connection errors, timeouts from remote resources etc.).
- Blueprints can provide blueprint specific error handlers.
- Implemented generic Pluggable Views (class-based views).
Version 0.6.1¶
Bugfix release, released on December 31st 2010
- Fixed an issue where the default OPTIONS response was not exposing all valid methods in the Allow header.
- Jinja2 template loading syntax now allows ”./” in front of a template load path. Previously this caused issues with module setups.
- Fixed an issue where the subdomain setting for modules was ignored for the static folder.
- Fixed a security problem that allowed clients to download arbitrary files if the host server was a windows based operating system and the client uses backslashes to escape the directory the files where exposed from.
Version 0.6¶
Released on July 27th 2010, codename Whisky
- after request functions are now called in reverse order of registration.
- OPTIONS is now automatically implemented by Flask unless the application explicitly adds ‘OPTIONS’ as method to the URL rule. In this case no automatic OPTIONS handling kicks in.
- static rules are now even in place if there is no static folder for the module. This was implemented to aid GAE which will remove the static folder if it’s part of a mapping in the .yml file.
- the
config
is now available in the templates as config. - context processors will no longer override values passed directly to the render function.
- added the ability to limit the incoming request data with the
new
MAX_CONTENT_LENGTH
configuration value. - the endpoint for the
flask.Module.add_url_rule()
method is now optional to be consistent with the function of the same name on the application object. - added a
flask.make_response()
function that simplifies creating response object instances in views. - added signalling support based on blinker. This feature is currently optional and supposed to be used by extensions and applications. If you want to use it, make sure to have blinker installed.
- refactored the way URL adapters are created. This process is now
fully customizable with the
create_url_adapter()
method. - modules can now register for a subdomain instead of just an URL prefix. This makes it possible to bind a whole module to a configurable subdomain.
Version 0.5.2¶
Bugfix Release, released on July 15th 2010
- fixed another issue with loading templates from directories when modules were used.
Version 0.5.1¶
Bugfix Release, released on July 6th 2010
- fixes an issue with template loading from directories when modules where used.
Version 0.5¶
Released on July 6th 2010, codename Calvados
- fixed a bug with subdomains that was caused by the inability to specify the server name. The server name can now be set with the SERVER_NAME config key. This key is now also used to set the session cookie cross-subdomain wide.
- autoescaping is no longer active for all templates. Instead it
is only active for
.html
,.htm
,.xml
and.xhtml
. Inside templates this behavior can be changed with theautoescape
tag. - refactored Flask internally. It now consists of more than a single file.
flask.send_file()
now emits etags and has the ability to do conditional responses builtin.- (temporarily) dropped support for zipped applications. This was a rarely used feature and led to some confusing behavior.
- added support for per-package template and static-file directories.
- removed support for create_jinja_loader which is no longer used in 0.5 due to the improved module support.
- added a helper function to expose files from any directory.
Version 0.4¶
Released on June 18th 2010, codename Rakia
- added the ability to register application wide error handlers from modules.
after_request()
handlers are now also invoked if the request dies with an exception and an error handling page kicks in.- test client has not the ability to preserve the request context for a little longer. This can also be used to trigger custom requests that do not pop the request stack for testing.
- because the Python standard library caches loggers, the name of the logger is configurable now to better support unittests.
- added TESTING switch that can activate unittesting helpers.
- the logger switches to DEBUG mode now if debug is enabled.
Version 0.3.1¶
Bugfix release, released on May 28th 2010
- fixed a error reporting bug with
flask.Config.from_envvar()
- removed some unused code from flask
- release does no longer include development leftover files (.git folder for themes, built documentation in zip and pdf file and some .pyc files)
Version 0.3¶
Released on May 28th 2010, codename Schnaps
- added support for categories for flashed messages.
- the application now configures a
logging.Handler
and will log request handling exceptions to that logger when not in debug mode. This makes it possible to receive mails on server errors for example. - added support for context binding that does not require the use of the with statement for playing in the console.
- the request context is now available within the with statement making it possible to further push the request context or pop it.
- added support for configurations.
Version 0.2¶
Released on May 12th 2010, codename Jägermeister
- various bugfixes
- integrated JSON support
- added
get_template_attribute()
helper function. add_url_rule()
can now also register a view function.- refactored internal request dispatching.
- server listens on <IP_ADDRESS> by default now to fix issues with chrome.
- added external URL support.
- added support for
send_file()
- module support and internal request handling refactoring to better support pluggable applications.
- sessions can be set to be permanent now on a per-session basis.
- better error reporting on missing secret keys.
- added support for Google Appengine.
Version 0.1¶
First public preview release.


JSON-XT compresses JSON documents into short URIs, using eXternal Templates. Depending on the application, these URIs are 25 - 35% of the original JSON document size.
This Open Source project is sponsored by Consensas
See jsonxt.io for more, as well as this paper for a lot more explanation.
A more formal description of the algorithm will come with traction and or time!
Source on GitHub, package on npm. Note that the Javascript module has no external dependecies!
npm install jsonxt
const jsonxt = require("jsonxt")
// sample data…
const original = {
"@context": {
"ical": "http://www.w3.org/2002/12/cal/ical#",
"xsd": "http://www.w3.org/2001/XMLSchema#",
"ical:dtstart": {
"@type": "xsd:dateTime"
}
},
"ical:summary": "Lady Gaga Concert",
"ical:location": "New Orleans Arena, New Orleans, Louisiana, USA",
"ical:dtstart": "2011-04-09T20:00:00Z"
}
const templates = {
"simple:1": {
"columns": [
{
"path": "ical:summary",
"type": "string"
},
{
"path": "ical:location",
"type": "string"
},
{
"path": "ical:dtstart",
"type": "isodatetime-epoch-base32"
}
],
"template": {
"@context": {
"ical": "http://www.w3.org/2002/12/cal/ical#",
"ical:dtstart": {
"@type": "xsd:dateTime"
},
"xsd": "http://www.w3.org/2001/XMLSchema#"
}
}
}
}
const TYPE = "simple"
const VERSION = "1"
The templates
can have multiple compression formats encoded,
they will be selected by TYPE and VERSION.
This will compress the original JSON payload into a URI
const packed = await jsonxt.pack(original, templates, TYPE, VERSION, "jsonxt.io")
Which yields:
jxt:jsonxt.io:simple:1:Lady~Gaga~Concert/New~Orleans~Arena%2C~New~Orleans%2C~Louisiana%2C~USA/16Q1EM0
This is a compression of 279 bytes to 101 bytes: 36% of the original size.
See test code for a more fully worked through example.
This will decompress the packed URI into the original URI.
const unpacked = await jsonxt.unpack(packed, jsonxt.resolve)
See test code for a more fully worked through example.
Resolving takes a "resolver name" like example.com
embedded in the URI
and a file name and retrieves a document.
The following rules are used:
https://
is assumed if no scheme)https://resolver/.well-known/name
Generally you can just use jsonxt.resolve
.
Note: that if we (as a community) can come up with a proof JWS that is small - for example, the Base64 MD5 of an existing proof, we can get all these credentials to sub-160 bytes!
See here for more details.
jxt:example.com:c4:1:Adrian/Steele//BgQAw7/TiX/-2097/CA-BC/H4/Bf7mYA/2/123-456-789/CA/BC/Port%20Jennifer/Shopper's/BgQAw7/eyJhbGciOiJQUzI1NiIsImI2NCI6ZmFsc2UsImNyaXQiOlsiYjY0Il19..QcFxH2IAl95ugL4zkBFFquyySkKCoigzQhkS-sZFBGonJjI2j1lSdLQfHHAB9sWDeXD35mTaSWxFWe-Rcw9JfsweDXhRVtiXa8-aANyrvhiXCm762bQcRcNX-I1PO3zxAW812UKW6pdAtAk2fIBK1Jsck3SdbrfpPRcIm1wgARjhWOHmyjhrj4mAo87JJTiF3iRpljFkE2b0cyI3J7zWmW3ddD8yM5TCGET5uE92_is8gpl1DCRKORnlcN1ipbVZTI6FhRlJFQVSfzH-NkTCUnjAVWsnYiTYgBdh8b4Z0TT26IxM2ULGr_2qxDeQKMLxmmmuncrYN_NTOkSdVb-iug
See here for more details. My understand is the encoding they are using now (CBOR-LD, Base64) yields a size of about 700 bytes.
jxt:example.com:w3vc:1:MoH/J07BX03/1183738569/OPL/NZ/BgLv0g/Bwtkpo/SMITH/Male/JOHN/urn%3Auvci%3Aaf5vshde843jf831j128fj/Bd5lLo/eyJhbGciOiJFZERTQSIsImI2NCI6ZmFsc2UsImNyaXQiOlsiYjY0Il19..a3UqIuKSOmCKrdn2knl_hCjiN4f4Ud1eO5ckwEHb623V9vdCwWCDB7GBHlRBYSI8ek2E-By7xysVFwutcpOeDg


--- layout: default title: Poopybrain test page ---
Your definitive source of information and misinformation


| Event Handler |
Description |
HTML elements |
| ONCLICK |
Occurs when the user clicks a form element or link. ONCLICK is an action event and is very appropriate for use in UI sonification. Other events such as ONLOAD, ONCHANGE, ONBLUR, ONSELECT, etc., are less directly connected to immediate user actions. |
buttons
submit buttons
reset buttons
radio buttons
checkboxes
links
|
| ONMOUSEOVER |
Occurs when the user moves the mouse pointer over a link. This is one of the more useful events to use in sonification as it allows one to sonify a user's movement over a Web page. Done in a tasteful manner, ONMOUSEOVER events can be used to script fun and engaging pages which give immediate gratification to the user. |
links
|
| ONMOUSEOUT |
Occurs when the user moves the mouse pointer out of an area (client-side image map) or link. Paired with the ONMOUSEOVER event, you will find this event to be one of the most frequently used in scripting sonified Web pages. |
links
client-side image map areas
|
| ONBLUR |
Occurs when the user removes input focus from a window, frame, or form element. |
windows
frames
all form elements
|
| ONFOCUS |
Occurs when the user gives input focus to a window, frame, or form element. |
windows
frames
all form elements
|
| ONLOAD |
Occurs when a page and associated media has finished loading. |
document body
|
| ONUNLOAD |
Occurs when the user leaves a page. |
document body
|
| ONABORT |
Occurs when the user aborts the loading of an image (for example by clicking a link or clicking the Stop button) |
images
|
| ONERROR |
Occurs when the loading of a document or image causes an error. |
images
windows
|
| ONSUBMIT |
Occurs when the user submits a form. |
submit button
|
| ONRESET |
Occurs when the user resets a form (clicks a Reset button). |
forms
|
| ONSELECT |
Occurs when the user selects a form element's input field. |
text fields
textareas
|
| ONCHANGE |
Occurs when the user changes the value of an element. |
text fields
textareas
select lists
|


“The British have little sense of pavement etiquette, preferring a slalom approach to pedestrian progress. When two strangers approach each other, it often results in the performance of a little gavotte as they double-guess in which direction the other will turn.”
“Telling people how to walk is simply not British.”
“But on the street? No, we don’t walk on the left or the right. We are British and wander where we will..”
import random # Pseudo random number generation
# Simulate two people walking towards each other 10 times
number_of_walks = 10
reds = [random.choice('LR') for k in range(number_of_walks)]
blues = [random.choice('LR') for k in range(number_of_walks)]
# Count the number of bumps
bumps = sum([reds[k] != blues[k] for k in range(number_of_walks)])
# Let us make this repeatable
def walk(number_of_walks):
"""
Simulate people walking along the pavement
"""
reds = [random.choice('LR') for k in range(number_of_walks)]
blues = [random.choice('LR') for k in range(number_of_walks)]
bumps = sum([reds[k] != blues[k] for k in range(number_of_walks)])
return bumps
# Let us plot a large number of these interactions
from bashplotlib.histogram import plot_hist # cli plots
plot_hist([walk(500) for k in range(1000)],
height=20, # Set the height
colour='red', # Set the colour
bincount=20, # Number of bins
showSummary=True) # Show a summary
# Let us make this repeatable
def plot_experiment(data):
return plot_hist(data,
height=20, # Set the height
colour='red', # Set the colour
bincount=20, # Number of bins
showSummary=True) # Show a summary
plot_experiment([walk(500) for k in range(1000)])
# What if everyone walks on the left?
def walk(number_of_walks):
"""
Simulate people walking along the pavement
"""
reds = [random.choice('L') for k in range(number_of_walks)]
blues = [random.choice('L') for k in range(number_of_walks)]
bumps = sum([reds[k] != blues[k] for k in range(number_of_walks)])
return bumps
plot_experiment([walk(500) for k in range(1000)])
# What if 1 person walks on the left and the other on the right?
def walk(number_of_walks):
"""
Simulate people walking along the pavement
"""
reds = [random.choice('L') for k in range(number_of_walks)]
blues = [random.choice('R') for k in range(number_of_walks)]
bumps = sum([reds[k] != blues[k] for k in range(number_of_walks)])
return bumps
plot_experiment([walk(500) for k in range(1000)])
# What if people mix and match?
red_strategy = (20, 80) # Walk on the left 20 out of 100 times
blue_strategy = (90, 10) # Walk on the left 90 out of 100 times
def walk(number_of_walks=500, red_strategy=(1,1), blue_strategy=(1,1)):
"""
Simulate people walking along the pavement
"""
reds = [random.choice('L' * red_strategy[0]
+ 'R' * red_strategy[1])
for k in range(number_of_walks)]
blues = [random.choice('L' * blue_strategy[0]
+ 'R' * blue_strategy[1])
for k in range(number_of_walks)]
bumps = sum([reds[k] != blues[k] for k in range(number_of_walks)])
return bumps
plot_experiment([walk(500, red_strategy, blue_strategy) for k in range(1000)])
# What is effect of mix and matching?
[walk(500, (1,0), (x, 100-x)) for x in range(100)]
# What is effect of mix and matching?
[walk(500, (1, 1), (x, 100-x)) for x in range(100)]
# Evolutionary dynamics
size_of_population = 100 # Number of people
number_of_rounds = 500 # How many rounds
death_rate = .05 # Chance of removal
reds = ['L' for k in range(size_of_population)]
blues = ['L' for k in range(size_of_population)]
red_data = [sum([k == 'L' for k in reds])]
blue_data = [sum([k == 'L' for k in reds])]
for rnd in range(number_of_rounds): # Loop through rounds
for j, pair in enumerate(zip(reds, blues)): # Loop through players
if pair[0] != pair[1]: # If bump
if random.random() < death_rate: # If mind change
reds[j], blues[j] = blues[j], reds[j]
red_data.append(sum([k == 'L' for k in reds])) # Data collection
blue_data.append(sum([k == 'L' for k in blues]))
# Evolutionary dynamics with a mutation rate:
size_of_population = 100 # Number of people
number_of_rounds = 500 # How many rounds
mutation_rate = .05 # Chance of changing strategy
death_rate = .05 # Chance of removal
reds = ['L' for k in range(size_of_population)]
blues = ['L' for k in range(size_of_population)]
red_data = [sum([k == 'L' for k in reds])]
blue_data = [sum([k == 'L' for k in reds])]
for rnd in range(number_of_rounds): # Loop through rounds
for j, pair in enumerate(zip(reds, blues)): # Loop through players
if random.random() < mutation_rate: # Check if random change
reds[j], blues[j] = random.choice('LR'), random.choice('LR')
if pair[0] != pair[1]: # If bump
if random.random() < death_rate: # If mind change
reds[j], blues[j] = blues[j], reds[j]
red_data.append(sum([k == 'L' for k in reds])) # Data collection
blue_data.append(sum([k == 'L' for k in blues]))
+VincentKnight
@drvinceknight
www.vincent-knight.com
github.com/drvinceknight/PyNam


Designer Notes
Introduction
Fantasy is the most overdone genre in the world of RPGs.
I designed Ruins & Raiders because my system and setting tastes are unusual. I want a fantasy game that is in the middle of the great RPG debates.
Goals for the system:
- A balance between realism and heroism
- A balance between roleplaying and hack-n-slash
- Simple character generation, but a wealth of possible characters
- Mechanics that are easy to learn
- Meaningful tactical options - but only for those who want them
- Minimal bookkeeping
In my eyes, combining the above makes a fun game.
The mechanics are unoriginal. R&R takes elements from the Hero System, West End Games's classic d6 system, Dungeons & Dragons, GURPS, Fudge, and many others.
Character Generation
The costs of traits increase with level to prevent munchkins from placing all their points into a single ability. Such characters are gods at one thing and useless at all else. The system is designed to discourage this.
The exponential increases also allow traits to be open-ended without fear that someone will have a Brawn of 700.
This cost scheme also means that it is painless for a character to gain a small amount of any trait. Mastery, on the other hand, requires dedication.
Skills are broad for the sake of simplicity. I have tried to group different abilities together under single traits in ways that make sense. Characters are less customizable than in games with hundreds of skills, but I think the ease of character building is worth the trade. Chargen is simpler with a small number of broad skills than with a large number of narrow ones.
The skill list focuses on adventuring abilities; trade skills are abstracted. I did this so that talented craftsmen and scholars can compete in the adventuring arena. All craft skills, from blacksmithing to shoemaking, are considered part of a single trait: Artisan. All academic skills are considered part of Scholar. This is unrealistic, but I think it's fun.
This is meant primarily for player characters - most NPCs will be specialists with professions like Farmer or Carpenter.
Skills can be added. If a player wants their character to have Singer or Sailor as a profession, let it be done.
The decision to leave out traits and skills related to social dynamics was deliberate. I prefer for such situations to be resolved through roleplaying rather than dice. If you want to be beautiful and dashing, fine. If you would rather be ugly and scary, good. There are advantages and disadvantages to both.
Gifts exist to add arbitrary rules and abilities to the game. One could add a gift called Bondage that allows one to control minds with a Willpower roll or a gift called Illusion that lets one do damage with a Perception roll. Taken to the extreme, one could even use gifts to emulate magic systems like those found in other games, where every spell is a rule unto itself.
An expensive Gift is required to prevent every character from having the ability.
Fortune is like a combination of drama points, hit points, and mana. It's an abstract resource that exists purely for game purposes. I think it's fun.
System Mechanics
The mechanics are meant to be easy to learn and simple to execute, yet powerful in possibility.
Goals:
- A single core mechanic
- Fast resolution
- Enough randomness to make the game gripping, but not so much that trait levels don't matter
- Optional details for tactics and sorcery
The game uses rolls of 2d6 + Trait as the core mechanic. The probability distribution looks like this:
| x | p(roll = x) | p(roll >= x) |
|---|---|---|
| 2 | 0.028 | 1.000 |
| 3 | 0.056 | 0.972 |
| 4 | 0.083 | 0.917 |
| 5 | 0.111 | 0.833 |
| 6 | 0.139 | 0.722 |
| 7 | 0.167 | 0.583 |
| 8 | 0.139 | 0.417 |
| 9 | 0.111 | 0.278 |
| 10 | 0.083 | 0.167 |
| 11 | 0.056 | 0.083 |
| 12 | 0.028 | 0.028 |
On average, players should roll a 7 about 17 percent of the time. 45 percent of rolls should fall between 6 and 8; 67 percent of rolls should fall between 5 and 9; 83 percent of rolls should fall between 4 and 10.
The degree-of-success mechanic takes care of several things at once - there is no need for damage rolls, hit locations, or techniques to allow a knife fighter to get through heavy armor. It's all there in the mox. It also means that trait checks are not just pass/fail; you get information on the quality of the success or failure.
The system is unconcerned with the detailed differences between types of weapons and armor. Players don't need to choose swords for tactical reasons if what they really want is axe-wielding barbarians. At the same time, a dagger shouldn't do the damage of a longsword; daggers have other advantages (small, lightweight, throwable). Therefore, the size of a weapon determines its benefits; Players choose the characteristics and cosmetics.
Random initiative adds some variety to the types of tactics possible in the game. Players can create a samurai-like warrior by putting emphasis on aggressive initiative and striking or a fencer who concentrates on fending off an opponent while seeking an opening.
Spellcasters ought to have options when casting a spell so that supernatural duels are as exciting as physical ones. Spell intensity, duration, area, and casting time should be flexible. The rules are designed so that spellcasters may trade one for another in various ways. This will hopefully lead to interesting tactics.
Powerful spellcasters need not be strong or quick - those in stories are often old and feeble. Thus, all of a spellcaster's abilities are based on his mind. The ability to defy or deflect spells without physically moving is part of this.


NOTE: splunkd is assumed to be configured as follows:
Run these tests to test login! and onSessionExpired.
This page tests passing a dict to authenticate. It:
This page tests pasing a function to authenticate. It:
This page tests that the default reauthentication happens when the session key is invalidated. It:
This page tests that a provided onSessionExpired function is called when the session key is invalidated.
This page tests that the username returned by the authenticate function is set as the value for the config username
A page that automatically redirects to a custom login page if unauthenticated.
This page tests basic functionality of TableView, SingleView, and all form inputs.
This page tests basic functionality of TimeRangeView.
This page tests basic functionality of Timeline.
This page tests basic functionality of EventsViewerView.
This page tests basic functionality of SplunkMapView.
This page tests basic functionality of SearchBarView.
This page tests basic functionality of ChartView.
This page tests basic functionality of global and local drilldown.
This page tests that the independent mode check is working.
This page tests that error logger that normally goes to the server is intercepted.
This page tests basic framework functionality when the static directory is moved to a different location.
This page tests basic framework functionality when the framework is loaded from the local filesystem using the file:// protocol.
These tests are the same as the above, but use minification.


APPLY NOW: Insider Inc. is hiring weekend news reporters, tech editors, and more, Business Insider - Business Insider Singapore
by Insider Inc., Business Insider USInsider Inc. has a number of editorial openings across both Business Insider and INSIDER. If you’re interested in joining a fast-paced, growing newsroom, apply at the links provided below. Unless otherwise stated, positions are located in our New York City headquarters and begin immediately.
Editorial fellowships
- Business Insider editorial fellow, strategy (WINTER/SPRING)
- Business Insider editorial fellow, tech, UK
- Business Insider editing fellow, strategy (WINTER/SPRING)
- Business Insider visual features fellow, retail (WINTER/SPRING)
- Business Insider visual features fellow, transportation (WINTER/SPRING)
- Business Insider Today copyediting fellowship (FALL/WINTER)
- Distribution fellow (WINTER/SPRING)
- Insider editorial fellow, military and defense (WINTER/SPRING)
- Insider editorial fellow, parenting (WINTER/SPRING)
- Markets Insider editorial fellow
- Markets Insider editorial fellow, UK
- Video research fellow, Business Insider Today (WINTER/SPRING)
- Video-producing fellow, shortform/Snapchat (WINTER/SPRING)
- Video producing and editing fellow, tech (WINTER/SPRING)
Full-time positions
Audio
Business Insider
- Assistant managing editor
- Associate editor, transportation
- Associate editor, visual features
- Associate editor, visual features, San Francisco
- Associate editor, finance
- Emerging technology reporter, New York, Seattle, or San Francisco
- Executive life mansions junior reporter
- Executive editor, UK
- Google reporter, SF
- Healthcare reporter
- Healthcare reporter, Washington D.C
- Management and strategy reporter, Business Insider Prime
- Media reporter
- Retail editor
- Small business reporter
- Tech reporter, UK
- Tech deputy editor
- Tech editor
- Tech editor, San Francisco
- Tech billionaires reporter, San Francisco
- Tech deals reporter, San Francisco or New York
- Tech ideas and innovation reporter
- Venture capital editor, San Francisco
- Venture capital/tech startups reporter, San Francisco
- Visual features reporter, airlines
- Visual features reporter, autos, Los Angeles
- Visual features reporter, San Francisco
- Visual features reporter, Los Angeles
- Visual features reporter, Seattle
- Visual features reporter, tech
- Visual features reporter, consumer
- Explainers editor
Insider
- Breaking news reporter
- Entertainment reporter, UK
- Internet and digital culture reporter
- Teen culture reporter
- Lifestyle editor
- News editor, UK
- News reporter, UK
- News reporter, breaking and weekends
- Politics reporter
- Style reporter
- Sex and relationships reporter
- Sex and relationships associate editor
- Sports reporter, New York or London
- Visual features reporter, breaking news
- Weekend culture reporter
- Weekend news editor
- Weekend news editor, UK
Markets Insider
Video
- Head of development
- Senior producer, Business Insider Today
- Senior producer, science
- Senior producer, Tech Insider
- Supervising producer
- Senior producer, animation
- Associate producer, Business Insider
- Associate producer/editor, Business Insider
- Producer, UK
For a constantly updated list of openings, see our careers page.


ID
age
language
Filter
Results of Filter


Revised: 09/08/2005
Introduction. Loosely speaking, a tolerance interval for a measured quantity is the interval in which there is some "likelihood" (or, of which you feel a some "level of confidence") that a specified fraction of the population's values lie, based on a sample that you measured from this population. Tolerance intervals have been widely used in statistical process control. This page will calculate tolerance intervals for any specified population fraction, and for any specified level of confidence, from the mean and standard deviation of a finite sample, under the assumption that the population is normally distributed. One-sided (upper and lower) intervals, as well as the two-sided interval, are calculated.
Reference: NIST/Sematech Engineering Statistics
Handbook, Section <IP_ADDRESS>
http://www.itl.nist.gov/div898/handbook/prc/section2/prc263.htm
The fields below are pre-loaded with sample data taken from one of the examples in this Handbook.
Note: The very last line on the Handbook page:
"The upper (one-sided) tolerance limit is therefore 97.07 + 1.8752*2.68
= 102.096."
is wrong. The standard deviation in their example is 0.0268, not 2.68, so
the answer should be 97.12, not 102.096 .
These calculations are also available in a downloadable Excel spreadsheet: tolintvl.xls .
Instructions: Enter the five parameters (N, mean, SD, confidence level, and coverage fraction) into the five cells below. Use the Tab key after entering each value. The calculations will be updated whenever you "leave" one of these five fields, either by tabbing out of it, or by clicking in another field.
Before using this page for the first time, make sure you read the JavaStat user interface guidelines.