API Payment
The Interswitch Payment Gateway APIs provides a seamless payment service that Service Providers can integrate to from your preferred application that facilitates realtime debits to cardholders’ accounts and onward credits to the partner client’s account.
- Client integrates using the Interswitch Payment Gateway APIs
- Client customizes customer entry point based on preferences
- Client passes card information and other authentication details to Interswitch
- Interswitch processes transaction and sends response to client
In order to extract structured data from a website, you only need two things. First, tell the crawler which pages it should visit (see Start URLs and Pseudo-URLs) and second, define a JavaScript code that will be executed on every web page visited in order to extract the data from it (see Page function). The crawler is a full-featured web browser which loads and interprets JavaScript and the code you provide is simply executed in the context of the pages it visits. This means that writing your data-extraction code is very similar to writing JavaScript code in front-end development, you can even use any client-side libraries such as jQuery or Underscore.js.
Imagine the crawler as a guy sitting in front of a web browser. Let's call him Bob. Bob opens a start URL and waits for the page to load, executes your JavaScript code using a developer console, writes down the result and then right-clicks all links on the web page to open them in new browser tabs. After that, Bob closes the current tab, goes to the next tab and repeats the same action again. Bob is pretty smart and skips pages that he has already visited. When there are no more pages, he is done. And this is where the magic happens. Bob would need about a month to click through a few hundred pages. Apify can do it in a few seconds and makes fewer mistakes.
More formally, the crawler repeats the following steps:
- Add each of the Start URLs into the crawling queue.
- Fetch the first URL from the queue and load it in the virtual browser.
- Execute Page function on the loaded page and save its results.
- Find all links from the page using Clickable elements CSS selector. If a link matches any of the Pseudo-URLs and has not yet been enqueued, add it to the queue.
- If there are more items in the queue, go to step 2, otherwise finish.
This process is depicted in the following diagram. Note that blue elements represent settings or operations that can be affected by crawler settings. These settings are described in detail in the following sections.
Note that each crawler configuration setting can also be set using the API, the corresponding property name and type is {described in this font} right next to the property caption. When you export the crawler settings to JSON, the object will have these properties. For details, see the API section on the crawler details page.
Basic settings
Custom ID {customId: String}
A custom unique identifier of the crawler that is used to reference the crawler from API integrations. The string cannot be empty and ideally should not require URL encoding. Beware: if you change this value, the corresponding API endpoint URL will also change and your integrations might break.
Internal ID {_id: String}
An internal unique identifier of the crawler that can be used to reference the crawler in your API integrations instead of Custom ID. Note that this value is read-only and never changes.
Start URLs {startUrls: [{key: String, value: String}]}
The list of URLs of the first pages that the crawler will open. Optionally, each URL can be associated with a custom label that can be referenced from your JavaScript code to determine which page is currently open (see Request object for details). Each URL must start with either a http://
or https://
protocol prefix!
Note that it is possible to instruct the crawler to load a URL using a HTTP POST request simply by suffixing it with a [POST]
marker, optionally followed by POST data (e.g. http://www.example.com[POST]
). By default, POST requests are sent with the Content-Type: application/x-www-form-urlencoded
header.
Maximum label length is 100 characters and maximum URL length is 2000 characters.
Pseudo-URLs {crawlPurls: [{key: String, value: String}]}
Specifies which pages will be visited by the crawler using a pseudo-URLs (PURL) format. PURL is simply a URL with special directives enclosed in []
brackets. Currently, the only supported directive is [regexp]
, which defines a JavaScript-style regular expression to match against the URL.
For example, a PURL http://www.example.com/pages/[(\w|-)*]
will match all of the following URLs:
http://www.example.com/pages/
http://www.example.com/pages/my-awesome-page
http://www.example.com/pages/something
If either [
or ]
is part of the normal query string, it must be encoded as [\x5B]
or [\x5D]
, respectively. For example, the following PURL:
http://www.example.com/search?do[\x5B]load[\x5D]=1
will match the URL:
http://www.example.com/search?do[load]=1
Optionally, each PURL can be associated with a custom label that can be referenced from your JavaScript code to determine which page is currently open (see Request object for details).
Note that you don't need to use this setting at all, because you can completely control which pages the crawler will access using the Intercept request function.
Maximum label length is 100 characters and maximum PURL length is 1000 characters.
Clickable elements {clickableElementsSelector: String}
CSS selector used to find links to other web pages. The crawler clicks all DOM elements matching this selector and then monitors whether the page generates a navigation request. If a navigation request is detected, the crawler checks whether it matches Pseudo-URLs, invokes Intercept request function, cancels the request and then continues clicking the next matching elements. By default, new crawlers are created with a safe CSS selector:
a:not([rel=nofollow])
.
In order to reach more pages, you might want to use a wider CSS selector, such as:
a:not([rel=nofollow]), input, button, [onclick]:not([rel=nofollow])
Be careful - clicking certain DOM elements can cause unexpected and potentially harmful side effects. For example, by clicking buttons you might submit forms, flag comments, etc. In principle, the safest option is to narrow the CSS selector to as few elements as possible, which also makes the crawler run much faster.
Leave this field empty if you do not want the crawler to click any elements and only open Start URLs or pages enqueued using enqueuePage()
.
Page function {pageFunction: String}
A user-provided JavaScript function that is executed in the context of every page loaded by the crawler. Page function is typically used to extract some data from the page, but it can also be used to perform some non-trivial operation on the page, e.g. handle AJAX-based pagination.
IMPORTANT: Apify is currently using PhantomJS headless web-browser, which only supports JavaScript ES5.1 standard (read more in a blog post about PhantomJS 2.0).
The basic page function with no effect has the following signature:
function pageFunction(context) {
return null;
}
The function can return an arbitrary JavaScript object (including array, string, number, etc.) that can be stringified to JSON; this value will be saved in the crawling results as the pageFunctionResult
field of the Request object corresponding to the web page on which the pageFunction
was executed. Note that Apify provides crawling results in a computer-friendly form (JSON, JSONL, XML or RSS format), as well as in a human-friendly tabular form (HTML or CSV format). If the pageFunction
's return value is an array, its elements will be displayed as separate rows in such a table, to make the results more readable.
The function accepts a single argument called context
, which is an object with the following properties and functions:
| Name | Description |
|---|---|
request |
An object holding all the available information about the currently loaded web page. See Request object for details. |
jQuery |
A jQuery object, only available if the Inject jQuery setting is enabled. |
underscoreJs |
The Underscore.js' _ object, only available if the Inject Underscore.js setting is enabled.
|
skipLinks() |
If called, the crawler will not follow any links from the current page and will continue with the next page from the queue. This is useful to speed up the crawl by avoiding unnecessary paths. |
skipOutput() |
If called, no information about the current page will be saved to the Results, including the page function result itself. This is useful to reduce the size of the output JSON by skipping unimportant pages. Note that if the page function throws an exception, the skipOutput() call is ignored and the page is outputted anyway, so that the user has a chance to determine whether there was an error (see Request object's errorInfo field).
|
willFinishLater() |
Tells the crawler that the page function will continue performing some background operation even after it returns. This is useful when you want to fetch results from an asynchronous operation, e.g. an XHR request or a click on some DOM element. If you use the willFinishLater() function, make sure you also invoke finish() or the crawler will wait infinitely for the result and eventually timeout after the period specified in Page function timeout. Note that the normal return value of the page function is ignored.
|
finish(result) |
Tells the crawler that the page function finished its background operation. The result parameter receives the result of the page function - this is a replacement for the normal return value of the page function that was ignored (see willFinishLater() above). |
saveSnapshot() |
Captures a screenshot of the web page and saves its DOM to an HTML file, which are both then displayed in the user's crawling console. This is especially useful for debugging your page function. |
enqueuePage(request) |
Adds a new page request to the crawling queue, regardless of whether it matches any of the Pseudo-URLs. The Note that the manually enqueued page is subject to the same processing as any other page found by the crawler. For example, the Intercept request function function will be called for the new request, and the page will be checked to see whether it has already been visited by the crawler and skipped if so. For backwards compatibility, the function also supports the following signature:enqueuePage(url, method, postData, contentType) .
|
saveCookies([cookies]) |
Saves current cookies of the current PhantomJS browser to the crawler's Initial cookies. All subsequently started PhantomJS processes will use these cookies. For example, this is useful to store a login. Optionally, you can pass an array of cookies to set to the browser before saving (in PhantomJS format). Note that by passing an empty array you can unset all cookies. |
customData |
Custom user data from crawler settings. See Custom data for details. |
stats |
An object containing a snapshot of statistics from the current crawl (see API section on crawler run page for details). Note that the statistics are collected before the current page has been crawled. |
actExecutionId |
String containing ID of this crawler execution. It might be used to control the crawler using the API, e.g. to stop it or fetch its results. |
actId |
String containing internal ID of crawler. See Internal ID for details. |
Note that any changes made to the context
parameter will be ignored. When implementing the page function, it is the user's responsibility not to break normal page's scripts which might affect the operation of the crawler.
Waiting for dynamic content
Some web pages do not load all their content immediately but only fetch it in the background using AJAX, while pageFunction
might be executed before the content has actually been loaded. You can wait for dynamic content to load using the following code:
function pageFunction(context) {
var $ = context.jQuery;
var startedAt = Date.now();
var extractData = function() {
// timeout after 10 seconds
if( Date.now() - startedAt > 10000 ) {
context.finish("Timed out before #my_element was loaded");
return;
}
// if my element still hasn't been loaded, wait a little more
if( $('#my_element').length === 0 ) {
setTimeout(extractData, 500);
return;
}
// refresh page screenshot and HTML for debugging
context.saveSnapshot();
// save a result
context.finish({
value: $('#my_element').text()
});
};
// tell the crawler that pageFunction will finish asynchronously
context.willFinishLater();
extractData();
}
Advanced settings
Intercept request function {interceptRequest: String}
A user-provided JavaScript function that is called whenever a new URL is about to be added to the crawling queue, which happens at the following times:
- At the start of crawling for all Start URLs.
- When the crawler looks for links to new pages by clicking elements matching the Clickable elements CSS selector and detects a page navigation request, i.e. a link (GET) or a form submission (POST) that would normally cause the browser to navigate to a new web page.
- Whenever a loaded page tries to navigate to another page, e.g. by setting
window.location
in JavaScript. - When user code invokes
enqueuePage()
inside of Page function.
The intercept request function allows you to affect on a low level how new pages are enqueued by the crawler. For example, it can be used to ensure that the request is added to the crawling queue even if it doesn't match any of the Pseudo-URLs, or to change the way the crawler determines whether the page has already been visited or not. Similarly to the Page function, this function is executed in the context of the originating web page (or in the context of about:blank
page for Start URLs).
IMPORTANT: Apify is currently using PhantomJS headless web-browser, which only supports JavaScript ES5.1 standard (read more in blog post about PhantomJS 2.0).
The basic intercept request function with no effect has the following signature:
function interceptRequest(context, newRequest) {
return newRequest;
}
The context
is an object with the following properties:
request |
An object holding all the available information about the currently loaded web page. See Request object for details. |
jQuery |
A jQuery object, only available if the Inject jQuery setting is enabled. |
underscoreJs |
An Underscore.js object, only available if the Inject Underscore.js setting is enabled. |
clickedElement |
A reference to the DOM object whose clicking initiated the current navigation request. The value is null if the navigation request was initiated by other means, e.g. using some background JavaScript action. |
Beware that in rare situations when the page redirects in its JavaScript before it was completely loaded by the crawler, the jQuery
and underscoreJs
objects will be undefined. The newRequest
parameter contains a Request object corresponding to the new page.
The way the crawler handles the new page navigation request depends on the return value of the interceptRequest
function in the following way:
- If function returns the
newRequest
object unchanged, the default crawler behaviour will apply. - If function returns the
newRequest
object altered, the crawler behavior will be modified, e.g. it will enqueue a page that would not normally be skipped. The following fields can be altered:willLoad
,url
,method
,postData
,contentType
,uniqueKey
,label
,interceptRequestData
andqueuePosition
(see Request object for details). - If function returns
null
, the request will be dropped and a new page will not be enqueued. - If function throws an exception, the default crawler behaviour will apply and the error will be logged to Request object's
errorInfo
field. Note that this is the only way a user can catch and debug such an exception.
Note that any changes made to the context
parameter will be ignored (unlike the newRequest
parameter). When implementing the function, it is the user's responsibility not to break normal page scripts that might affect the operation of the crawler. You have been warned. Also note that the function does not resolve HTTP redirects: it only reports the originally requested URL, but does not open it to find out which URL it eventually redirects to.
Options
URL #fragments identify unique pages {considerUrlFragment: Boolean}
Indicates that the URL fragment identifier (i.e. http://www.example.com/page#this-guy-here
) should be considered when matching an URL against a PURL or when checking whether a page has already been visited. Typically, URL fragments are used as internal page anchors and therefore they should be ignored because they don't represent separate pages. However, many AJAX-based website nowadays use URL fragment to represent page parameters; in such cases, this option should be enabled.
Download HTML images {loadImages: Boolean}
Indicates whether the crawler should load HTML images, both those included using the <img>
tag as well as those included in CSS styles. Disable this feature after you have fine-tuned your crawler in order to increase crawling performance and reduce your bandwidth costs.
Download CSS files {loadCss: Boolean}
Indicates whether the crawler should load CSS stylesheet files. Disable this feature after you have fine-tuned your crawler in order to increase crawling performance and reduce your bandwidth costs.
Inject jQuery {injectJQuery: Boolean}
Indicates that the jQuery library should be injected to each page before Page function is invoked. Note that the jQuery object will not be registered into global namespace in order to avoid conflicts with libraries used by the web page. It can only be accessed through context.jQuery
.
Inject Underscore.js {injectUnderscoreJs: Boolean}
Indicates that the Underscore.js library should be injected to each page before Page function is invoked. Note that the Underscore object will not be registered into global namespace in order to avoid conflicts with libraries used by the web page. It can only be accessed through context.underscoreJs
.
Ignore robots exclusion standards {ignoreRobotsTxt: Boolean}
Indicates that the crawler should ignore robots.txt
, <meta name="robots">
tags and X-Robots-Tag
HTTP headers. Use this feature at your own risk!
Don't load frames and IFRAMEs {skipLoadingFrames: Boolean}
Indicates that child frames included using FRAME or IFRAME tags will not be loaded by the crawler. This might improve crawling performance. As a side-effect, JavaScript redirects issued by the page before it was completely loaded will not be performed, which might be useful in certain situations.
Verbose log {verboseLog: Boolean}
If enabled, the log will also contain DEBUG messages. Note that this setting will dramatically slow down the crawler as well as your web browser and increase the log size.
Disable web security {disableWebSecurity: Boolean}
If checked, the virtual browser will allow cross-domain XHRs and untrusted SSL certificates, so that your crawler can access content from any domain. Only activate this feature if you know what you're doing!
Rotate User-Agent headers {rotateUserAgents: Boolean}
If checked then the crawler automatically rotates the User-Agent
HTTP header for each new IP address, from a pre-defined list. This settings overwrites Custom HTTP headers with key User-Agent
if it is set.
Max pages per crawl {maxCrawledPages: Number}
Maximum number of pages that the crawler will open. The crawl will stop when this limit is reached. Always set this value in order to prevent infinite loops in misconfigured crawlers. For free plan users, the maximum is limited according to the current Monthly pages limit of the free plan (see pricing for details). Note that in cases of parallel crawling, the actual number of pages visited might be slightly higher than this value.
Max result records {maxOutputPages: Number}
Maximum number of pages the crawler can output to JSON. The crawl will stop when this limit is reached. This value is useful when you only need a limited number of results.
Max crawling depth {maxCrawlDepth: Number}
Defines how many links away from the start URLs the crawler will descend. This value is a safeguard against infinite crawling depths on misconfigured crawlers. Note that pages added using enqueuePage()
(see Page function) are not subject to the maximum depth constraint.
Execution timeout {timeout: Number}
Timeout for the execution of the crawler, in seconds. If the crawler is running longer than this value, it will be forcibly stopped and its status set to TIMEOUT
. By default, the timeout is 604800 seconds (=7 days).
Resource timeout {resourceTimeout: Number}
Timeout for network resources loaded by the crawler specified in milliseconds. The default value is 30000
milliseconds.
Page load timeout {pageLoadTimeout: Number}
Timeout for web page load, in milliseconds. If the web page does not load in this timeframe, it is considered to have failed and will be retried, similarly as with other page load errors. The default value is 60000
milliseconds.
Page function timeout {pageFunctionTimeout: Number}
Timeout for the asynchronous part of the page function, in milliseconds. Note that this value is only applied if your page function runs code in the background, i.e. when it invokes context.willFinishLater()
; the page function itself always runs to completion regardless of the timeout. The default timeout is 600000
milliseconds (= 10 minutes). .
Infinite scroll height {maxInfiniteScrollHeight: Number}
Defines the maximum client height in pixels to which the browser window is scrolled in order to fetch dynamic AJAX-based content from the web server (so-called infinite scroll). By default, the crawler doesn't scroll and uses a fixed browser window size. Note that you might need to enable Download HTML images to make infinite scroll work, because otherwise the crawler wouldn't know that some resources are still being loaded and will stop infinite scrolling prematurely.
Delay between requests {randomWaitBetweenRequests: Number}
This option forces the crawler to ensure a minimum time interval between opening two web pages, in order to prevent it from overloading the target server. The actual minimum time is a random value drawn from a Gaussian distribution with a mean specified by your setting (in milliseconds) and a standard deviation corresponding to 25% of the mean. The minimum value is 2000 milliseconds, the crawler never issues requests in shorter intervals than
Max pages per IP address {maxCrawledPagesPerSlave: Number}
Maximum number of pages that a single crawling process will open before it is restarted with a new proxy server setting. This option can help avoid the blocking of the crawler by the target server and also ensures that the crawling processes don't grow too large, as they are killed periodically. The default is 50.
Parallel crawling processes {maxParallelRequests: Number}
The number of parallel processes that will perform the crawl. If more than one, page screenshots and HTML snapshots are disabled, because they would switch too quickly and it would make no sense for them to be enabled. The maximum value is determined by your subscription type (see Account for your service limits). Note that each of the parallel crawling processes typically uses a different IP address for outgoing HTTP requests.
Custom HTTP headers {customHttpHeaders: [{key: String, value: String}]}
Defines custom HTTP headers used by the crawler. The maximum length of the header name is 100 characters and the maximum length of the value is 1000 characters.
Proxy groups {proxyGroups: [String]}
Groups of proxy servers to be used by the crawler. All servers from all groups are combined into a single list and randomly shuffled at the start of your crawler run.
If you prefer to use your own proxy servers, check the Custom proxy group and enter the proxy servers into the Custom proxies field.
Custom proxies {customProxies: String}
A list of custom proxy servers to be used instead of the default Apify proxies, specified in the format scheme://user:password@host:port
. The URL scheme defines the proxy type, possible values are http
and socks5
. User and password might be omitted, but the port must always be present. Separate proxies are separated by spaces or new lines.
The custom proxy used to fetch a specific page is stored to the proxy
field of the Request object. Note that for security reasons, the usernames and passwords are redacted from the proxy URL.
Custom data {customData: Anything}
Custom user data passed to the page function and intercept request function as context.customData
. This setting is mainly useful if you're invoking the crawler using an API, so that you can pass some arbitrary parameters to your code. In the crawler settings editor the value can only be a string, but when passing it through the API it can be an arbitrary JSON-stringifyable object.
Finish webhook URL {finishWebhookUrl: String}
A custom endpoint that receives a HTTP POST right after every run of the crawler ends, regardless of its status, i.e. whether it finished, failed, was stopped, etc. The POST payload is a JSON object defining an _id
property which contains an execution ID of the crawler run and actId
which contains internal ID of crawler, e.g. {_id: "S76d9xzpvY7NLfSJc", actId: "lepE4f93lkDPqojdC"}
. You can use this ID to query the crawl status and results using the API. Beware that the JSON object might be extended with other properties in the future.
The response to the POST request must have a HTTP status code in 2XX
range. Otherwise it is considered an error and the request is periodically retried every hour. If the request does not succeed after 48 hours, the system gives up and stops sending the requests.
For safety reasons, your URL should contain a secret token to ensure only Apify can invoke it. To test your endpoint, you can use one of the example crawlers. If your endpoint performs a time-consuming operation, you should respond to the request immediately so that it does not time out before Apify receives the response. The timeout of the webhook is 5 minutes. In rare circumstances, the webhook might be invoked more than once, you should design your code to be idempotent to duplicate calls.
You can test your webhook endpoint by clicking the Test button right next to your webhook URL. This will create a dummy crawl that is immediately finished and has zero results, whose only purpose is to test the finish webhook in real-world conditions.
Pro tip: If you want to run your crawler in an infinite loop, i.e. start a new run right after the previous one finishes, simply set the start crawler API endpoint as your finish webhook.
Finish webhook data {finishWebhookData: String}
You can add custom string to be sent in the finish webhook's POST request. If you set value of this field to my value
then the JSON object sent as POST request payload will look as follows:
{
_id: "S76d9xzpvY7NLfSJc",
actId: "lepE4f93lkDPqojdC",
data: "my value",
}
Test URL {testUrl: {key: String, value: String}}
A single URL with an optional label to test your crawler on. When using this to start the crawler, all Start URLs will be ignored and the crawler will be run for this URL only. All the Pseudo-URLs stay in place to allow for navigation testing.
Crawler internals
Request object
This object contains all the available information about every single web page the crawler encounters (both visited and not visited). This object comes into play in both Page function and Intercept request function and crawling results are actually just an array of these objects.
The Request object has the following schema:
{
// A string with a unique identifier of this Request object.
// It is generated from the uniqueKey, therefore two pages from various crawls
// with the same uniqueKey will also have the same ID.
id: String,
// The URL that was specified in the web page's navigation request,
// possibly updated by the 'interceptRequest' function
url: String,
// The final URL reported by the browser after the page was opened
// (will be different from 'url' if there was a redirect)
loadedUrl: String,
// Date and time of the original web page's navigation request
requestedAt: Date,
// Date and time when the page load was initiated in the web browser, or null if it wasn't
loadingStartedAt: Date,
// Date and time when the page was actually loaded, or null if it wasn't
loadingFinishedAt: Date,
// HTTP status and headers of the loaded page.
// If there were any redirects, the status and headers correspond to the final response, not the intermediate responses.
responseStatus: Number,
responseHeaders: Object,
// If the page could not be loaded for any reason (e.g. a timeout), this field contains a best guess of
// the code of the error. The value is either one of the codes from QNetworkReply::NetworkError codes
// or value 999 for an unknown error. This field is used internally to retry failed page loads.
// Note that the field is only informative and might not be set for all types of errors,
// always use errorInfo to determine whether the page was processed successfully.
loadErrorCode: Number,
// Date and time when the page function started and finished
pageFunctionStartedAt: Date,
pageFunctionFinishedAt: Date,
// An arbitrary string that uniquely identifies the web page in the crawling queue.
// It is used by the crawler to determine whether a page has already been visited.
// If two or more pages have the same uniqueKey, then the crawler only visits the first one.
//
// By default, uniqueKey is generated from the 'url' property as follows:
// * hostname and protocol is converted to lower-case
// * trailing slash is removed
// * common tracking parameters starting with 'utm_' are removed
// * query parameters are sorted alphabetically
// * whitespaces around all components of the URL are trimmed
// * if the 'considerUrlFragment' setting is disabled, the URL fragment is removed completely
//
// If you prefer different generation of uniqueKey, you can override it in the 'interceptRequest'
// or 'context.enqueuePage' functions.
uniqueKey: String,
// Describes the type of the request. It can be either one of the following values:
// 'InitialAboutBlank', 'StartUrl', 'SingleUrl', 'ActorRequest', 'OnUrlChanged', 'UserEnqueued', 'FoundLink'
// or in case the request originates from PhantomJS' onNavigationRequested() it can be one of the following values:
// 'Undefined', 'LinkClicked', 'FormSubmitted', 'BackOrForward', 'Reload', 'FormResubmitted', 'Other'
type: String,
// Boolean value indicating whether the page was opened in a main frame or a child frame
isMainFrame: Boolean,
// HTTP POST payload
postData: String,
// Content-Type HTTP header of the POST request
contentType: String,
// Contains "GET" or "POST"
method: String,
// Indicates whether the page will be loaded by the crawler or not
willLoad: Boolean,
// Indicates the label specified in startUrls or crawlPurls config settings where URL/PURL corresponds
// to this page request. If more URLs/PURLs are matching, this field contains the FIRST NON-EMPTY
// label in order in which the labels appear in startUrls and crawlPurls arrays.
// Note that labels are not mandatory, so the field might be null.
label: String,
// ID of the Request object from whose page this Request was first initiated, or null.
referrerId: String,
// Contains the Request object corresponding to 'referrerId'.
// This value is only available in pageFunction and interceptRequest functions
// and can be used to access properties and page function results of the page linking to the current page.
// Note that the referrer Request object DOES NOT recursively define the 'referrer' property.
referrer: Object,
// How many links away from start URLs was this page found
depth: Number,
// If any error occurred while loading or processing the web page,
// this field contains a non-empty string with a description of the error.
// The field is used for all kinds of errors, such as page load errors, the page function or
// intercept request function exceptions, timeouts, internal crawler errors etc.
// If there is no error, the field is a false-ish value (empty string, null or undefined).
errorInfo: String,
// Results of the user-provided 'pageFunction'
pageFunctionResult: Anything,
// A field that might be used by 'interceptRequest' function to save custom data related to this page request
interceptRequestData: Anything,
// Total size of all resources downloaded during this request
downloadedBytes: Number,
// Indicates the position where the request will be placed in the crawling queue.
// Can either be 'LAST' to put the request to the end of the queue (default behavior)
// or 'FIRST' to put it before any other requests.
queuePosition: String,
// Custom proxy used by the crawler, or null if custom proxies were not used.
// For security reasons, the username and password are redacted from the URL.
proxy: String
}
Comments {comments: String}
Arbitrary notes or comments associated with this crawler.


Mayor’s Arts Award is an award show in Muncie Indiana that honors local and upcoming artists. The award show was rebranded by Studio 165+, an immersive class at Ball State University. Our logo visually references Muncie cultural landmarks. The project consists of identity, promotional, event items, print, and web materials.
DESIGNERS: Sean Chen, Karissa Place, Anna Weddle, Tia Zook, Natalie Rokosz, Jessica Hord


At LacerMate we believe in inclusivity. Struggle to bend your back to tie your shoes? No problem. We have designed our product to make shoe tying easy and effortless for those who suffer from back pain.
Our design makes it easy to fit the product on most types of shoes. No need to buy special shoes. Simply add on the device on to your existing shoes.
Our product is the first on the market that is fully retrofittable and completely rids the need for bending. Other similar products on the market usually lack one or both of these qualities, are either designed for sport or aesthetically unpopular.
Head of Digital
Spongebob is the head of digital at LacerMate, where he is responsible for overseeing the product's smart capabilities. Together with his team, he is currently developing the remotely controlled pressure adjustment system.
Prior to joining LacerMate, Spongebob held various roles in the wireless industry. He worked in business development at IBM Group, and spent several years in Broadcom. Quinn received his MBA from Under-the-Sea University, and his Ph.D. in Electrical Engineering from Rock Bottom University in St. Louis.Head of Concept
Sandy has an extensive background in the apparrel, footwear, and fashion industries as well as in developing new companies, markets, and products globally. Her career spans over 3 continents and is truly international.
At LacerMate, Sandy's team is responsible for defining the product's capabilities and researching various concept versions for different markets.Head of Business Development
At LacerMate Mr Krabs is Head of Business Development, where he is responsible for its commercial strategy, sales, marketing, product development and customer service to drive rapid scale up and business growth.
Senior Materials Designer
Squidward holds a B.S. in Materials Engineering and an M.S in Engineering Mechanics, both from Under-The-Sea University. Prior to becoming Senior Materials Designer at LacerMate, he worked as a technical consultant for shoe giant Mike.
At LacerMate, Squidward and his team spend their days in the laboratory researching state-of-the art material options for use in the product.
Head of Manufacturing
Patrick heads the manufacturing department at LacerMate and oversees all the processes involved in the make of the product.
Patrick has a vast amount of experience after spending 17 years analysing the plant manufacturing processing of high performance polymers (PEEK, PAEK), developing new analytical methods and organic synthesis in R&D department and leading Quality Control teams.
General Information:
<EMAIL_ADDRESS>Location:
The Invention Rooms, London.
Investors:
<EMAIL_ADDRESS>The tools used for the website were GIT and GITHUB and the text editor Atom. A Bootstrap theme was used as the basis of the website. GitHub was chosen because of the large online community and open source content that can be utilised for guidance. Moreover, GitHub hosts source code projects in a variety of different programming languages and keeps track of the various changes made to every iteration. Continuous integration automatically builds and tests the code it goes into GitHub, preventing bugs from developing. Continuous deployment means that a deployment pipeline automatically picks up the changes. It means it is possible to streamline the code implementation so we could focus on the product. GitHub also makes it easy when working in a group to keep track of various changes different group members have made.
Step1 1: Decide on an available domain name that is descriptive of the website, easy to remember. You will have the choice to register the domain on several different top-level domains if available such as .com, .org, .biz, and .net.
Step 2: Visit a domain name registrar such as gandi.net, Domain.com and input the chosen domain name.
Step 3: Choose a company with which to register and host your domain and ensure that they are GDPR compliant. This is the company that is responsible for maintaining the website online. Examples include GoDaddy, Hover and BlueHost.
Step 4: Decide how long you wish to hold the domain name for and pay for the domain name through the company chosen.
Step 5: Purchase a web hosting account and launch a website under your domain.


The latest draft, reference header, and links to past discussions on Github:
The proposal enhances std::bitset
by adding a new template parameter which
allows the programmer to control the size and alignment of the underlying representation
along with a few additional public members.
This proposal is aimed for a C++ Technical Specification.
This proposal is a pure library extension. It changes the
template signature of std::bitset
by adding a new template parameter.
It also adds 2 new aliases std::fast_bitset
and std::small_bitset
,
3 new public members, a new constructor overload and a new assignment operator overload.
Implementation of this proposal will likely break the ABI of all standard library
implementations of std::bitset
. Adding a new template parameter may change the mangled
name of the type. If accepted, the deployment date of this proposal into the standard should
be carefully considered to avoid too many ABI breaks.
When dealing with bits, the classical method of implementation is to use an unsigned integral type and perform bit operations using logical operations, shifts, and masks.
With C++11, we have std::bitset
which is a nice abstraction for acting on the individual
bits of a fixed size quantity. The objective
of std::bitset
should be to entirely replace unsigned integers for implementing small collections of
bit flags.
Often times, sets of bits or flags are included in binary protocols or
other tightly packed small objects in memory. Due to the precise
size and alignment requirements of such domains, std::bitset
is
unusable because the programmer has no control over the alignment or
size of std::bitset
. Indeed it appears that std::bitset
on
x86_64 linux gcc is always at least 8 bytes.
In some situations, the
overhead of the extra space makes bitset unusable.
In addition, sometimes users may want a bitset
object whose underlying representation
has been automatically optimize for speed or space on a given platform. For this we provide
fast_bitset
and small_bitset
.
We will now describe the additions to the <experimental/bitset>
header.
This new declaration is aimed to eventually replace the current std::bitset
.
namespace std {
namespace experimental {
template <size_t N, typename T = /* Implementation defined */>
class bitset;
} //namespace experimental
} // namespace std
std::bitset<N,T>
shall have the following constraints:
static_assert(is_integral<T>::value);
static_assert(alignof(bitset<N,T>) == alignof(T[N / (sizeof(T) * CHAR_BIT) + (n % (sizeof(T) * CHAR_BIT) != 0)];
static_assert(sizeof(bitset<N,T>) == sizeof(T[N / (sizeof(T) * CHAR_BIT) + (n % (sizeof(T) * CHAR_BIT) != 0)];
There are no changes being proposed to the current set of members of std::bitset
.
[Note: bitset<N,T>
is not required to actually be implemented using an array of type T
, it only needs to satisfy the size and alignment constraints. --end node]
T
The default type T
used for std::bitset<N,T>
is implementation defined. This behavior is provided
for backwards source compatibility with C++14. We offer the following recommendations for
platforms in choosing which type to use.
T
as to optimize for speed (see below: fast_bitset<N>
)T
as to optimize for space (see below: small_bitset<N>
)T
to optimize for speed or space.A conforming implementation could be constructed using the following data model.
template <size_t N, typename T>
struct alignas(T) bitset {
array<T, N / (sizeof(T) * CHAR_BIT) + (n % (sizeof(T) * CHAR_BIT) != 0)> data;
};
Note that this implementation also works on Linux i386 where sizeof(long long) == 8
but struct t { long long x; }; alignof(t) == 4
.
We propose to add the following public members to std::bitset
:
template <size_t N, typename T>
using bitset<N,T>::underlying_type = std::array<T, N / (sizeof(T) * CHAR_BIT) + (n % (sizeof(T) * CHAR_BIT) != 0)>;
The underlying_type
typedef is present to inform the programmer what kind of storage is being used by the bitset
.
The bitset
must have the same size and alignment as this type.
template <size_t N, typename T>
underlying_type& bitset<N,T>::underlying() noexcept;
template <size_t N, typename T>
const underlying_type& bitset<N,T>::underlying() const noexcept;
These 2 accessors allow the programmer manual access to the underlying storage.
The values of the bits from 0
to N-1
in the returned reference will be the same as the corresponding bits in the bitset.
The values of the bits >= N
in the returned reference are implementation defined.
Any modifications performed on bits 0
to N-1
of the returned reference will also be performed on the bitset
object. Likewise modifying the bits in the bitset
will also modify the bits of the reference.
Modifying any bits >= N
will have no effect on the underlying bitset and their state is not guaranteed to remain
consistent after calling any member function of bitset
or any free function which modifies bitset
.
Note that while we do not require implementations to actually use underlying_type
to implement bitset
, we do require them to
match the size and alignment constraints of underlying_type
. Therefore if bitset is implemented using a different type, the
implementation can internally perform a cast to underlying_type
to implement these methods.
A bitset using one representation T
may be copied from another bitset using a different representation U
. We add the following
constructor and assignment operator overloads.
template <size_t N, typename T> template <typename U>
constexpr bitset<N,T>::bitset(const bitset<N,U>& other) noexcept;
template <size_t N, typename T> template <typename U>
constexpr bitset<N,T>& bitset<N,T>::operator=(const bitset<N,U>& other) noexcept;
The type fast_bitset<N>
shall be an alias for std::bitset<N,T>
, where T
is chosen to be the fastest underlying representation for N
bits.
template <size_t N>
struct __fast_bitset_type : public
std::conditional<N > 32, uint_fast64_t,
std::conditional<N > 16, uint_fast32_t,
std::conditional<N > 8, uint_fast16_t,
uint_fast8_t
>
>
> {};
template <size_t N> using fast_bitset = bitset<N,typename __fast_bitset_type<N>::type>;
The type fast_bitset<N>
shall be an alias for std::bitset<N,T>
, where T
is chosen to be the smallest underlying representation for N
bits.
Note that there are no restrictions on alignment.
template <size_t N>
struct __small_bitset_type : public
std::conditional<N % 64 > 32 || N % 64 == 0, uint_least64_t,
std::conditional<N % 64 > 16, uint_least32_t,
std::conditional<N % 64 > 8, uint_least16_t,
uint_least8_t
>
>
> {};
template <size_t N> using small_bitset = bitset<N,typename __small_bitset_type<N>::type>;


ASCII Math
Given: a=4, b=9
Solve: {4 - [8 * (5-2)] + 3} * 6
LaTeX Math
Given: \(a=4, b=9\)
Find \(x\): \[x = \sqrt{\frac{a}{b}} \]
Symbols
#X means the cardinality of the set X.
#{4, 6, 8} = 3
# is product of all prime numbers less than or equal to n.
12# = 2 × 3 × 5 × 7 × 11 = 2310


Fish Patient
A patient at **Aquatic** Veterinary Services.
Veterinarian
A profile on the Practitioner resource for veterinarians. In the US, vets do not have National Provider Numbers.


library(ggplot2)
library(tibble)
m <- 50 # population mean
sd <- 10 # population standard deviation
ggplot(data.frame(x = c(0, 100)), aes(x)) + theme_linedraw() +
stat_function(fun = dnorm, args = list(mean = m, sd = sd)) +
labs(y = "Density") +
theme(axis.text = element_text(size = 14),
axis.title = element_text(size = 16),
plot.title = element_text(size=20)) +
ggtitle(paste0("Normal distribution: mean = ",m,", sd = ",sd))
# ggsave(filename = "./figures/nb4_normdist.pdf")
set.seed(4)
n <- 20 # sample size
samp <- rnorm(n, m, sd) # generate random sample
ggplot(data.frame(x = c(0, 100)), aes(x)) + theme_linedraw() +
stat_function(fun = dnorm, args = list(mean = m, sd = sd)) +
geom_vline(xintercept = samp, colour = "grey") +
labs(y = "Density") +
theme(axis.text = element_text(size = 14),
axis.title = element_text(size = 16),
plot.title = element_text(size=20)) +
ggtitle(paste0("Normal distribution: mean = ",m,", sd = ",sd))
# ggsave(filename = "./figures/nb4_normdist_1samp.pdf")
Same figure as above with the sample mean superimposed.
set.seed(4)
n <- 20
samp <- rnorm(n, m, sd)
ggplot(data.frame(x = c(0, 100)), aes(x)) + theme_linedraw() +
stat_function(fun = dnorm, args = list(mean = m, sd = sd)) +
geom_vline(xintercept = samp, colour = "grey") +
geom_vline(xintercept = mean(samp), size = 2) +
labs(y = "Density") +
theme(axis.text = element_text(size = 14),
axis.title = element_text(size = 16),
plot.title = element_text(size=20)) +
ggtitle(paste("Sample mean =",round(mean(samp),digits=1),", sd = ",round(sd(samp),digits=1)))
# ggsave(filename = "./figures/nb4_normdist_1samp_mean.pdf")
Now we do 10,000 experiments, each time sampling from the same normal distribution and computing the sample mean. The graph below illustrates 10,000 sample means.
set.seed(111)
n <- 20 # sample size
nsim <- 10000 # number of simulations / experiments
# generate sampling distribution in one go:
samp.dist <- apply(matrix(rnorm(n*nsim, m, sd),nrow = nsim), 1, mean)
ggplot(data.frame(x=samp.dist), aes(x)) + theme_linedraw() +
geom_histogram(aes(y = ..density..), colour = "black", fill = "white", bins = 50) +
theme(axis.text = element_text(size = 14),
axis.title = element_text(size = 16),
plot.title = element_text(size=20)) +
ggtitle(paste(nsim,"sample means: mean =",round(mean(samp.dist),digits=1),", sd = ",round(sd(samp.dist),digits=2)))
# ggsave(filename = "./figures/nb4_normdist_10000samp_mean.pdf")
SEM is defined as: population sd / sqrt(n)
sd / sqrt(n)
## [1] 2.236068
In practice, we do not have access to the population, so SEM is usually estimated using sample sd / sqrt(n).
SEM can also be defined as the sd of the sampling distribution of the sample mean.
sd(samp.dist)
## [1] 2.255003
This value is very close to the previous one. If we increase the size of sampling distribution, by computing 100,000 or 1,000,000 or more sample means, the standard deviation of the sampling distribution will converge towards 2.236 precisely.
For more on the SEM, see this excellent video.
Blog post on how to use rlnorm()
.
# population
m <- 5
s <- 5
location <- log(m^2 / sqrt(s^2 + m^2))
shape <- sqrt(log(1 + (s^2 / m^2)))
x <- seq(0, 20, .05)
ggplot(tibble::enframe(x), aes(value)) +
theme_linedraw() +
stat_function(fun = dlnorm, args = list(meanlog = location, sdlog = shape), size = 1) +
labs(y = "Density") +
theme(axis.title = element_text(size = 16),
axis.text = element_text(size = 14),
plot.title = element_text(size=20)) +
ggtitle(paste0("Log normal distribution: mean = ",m,", sd = ",s))
# ggsave(filename = "./figures/nb4_lnormdist.pdf")
set.seed(777)
n <- 20
samp <- rlnorm(n, meanlog = location, sdlog = shape)
x <- seq(0, 20, .05)
ggplot(as_tibble(x), aes(value)) +
theme_linedraw() +
stat_function(fun = dlnorm, args = list(meanlog = location, sdlog = shape), size = 1) +
geom_vline(xintercept = samp, colour = "grey") +
geom_vline(xintercept = mean(samp), size = 1.5) +
labs(y = "Density") +
theme(axis.text = element_text(size = 14),
axis.title = element_text(size = 16),
plot.title = element_text(size=20)) +
ggtitle(paste0("Log normal distribution: mean = ",m,", sd = ",sd))
# ggsave(filename = "./figures/nb4_lnormdist_1samp.pdf")
set.seed(777)
m <- 5
s <- 5
location <- log(m^2 / sqrt(s^2 + m^2))
shape <- sqrt(log(1 + (s^2 / m^2)))
# population mean?
lnorm.pop.m <- mean(rlnorm(1000000, meanlog = location, sdlog = shape))
n <- 20
nsamp <- 10000
# nsamp experiments in one go + compute mean for each one:
dist.samp <- apply(matrix(rlnorm(n*nsamp, meanlog = location, sdlog = shape), nrow = nsamp), 1, mean)
v <- as_tibble(dist.samp)
ggplot(v, aes(x = value)) + theme_linedraw() +
geom_histogram(aes(y = ..density..), colour = "black", fill = "white", bins = 50) +
# geom_vline(xintercept = mean(dist.samp), size = 1.5) +
theme(axis.text = element_text(size = 14),
axis.title = element_text(size = 16),
plot.title = element_text(size=20)) +
ggtitle(paste(nsim,"sample means: mean =",round(mean(dist.samp),digits=1),", sd = ",round(sd(dist.samp),digits=2)))
# ggsave(filename = "./figures/nb4_lnormdist_10000samp_mean.pdf")
Based on (otherwise unobservable) population:
s / sqrt(n)
## [1] 1.118034
Based on (otherwise unachievable) 10,000 experiments:
sd(dist.samp)
## [1] 1.121328
Based on one sample:
sd(samp) / sqrt(n)
## [1] 1.172885
set.seed(777)
n <- 100 # sample size
nsamp <- 10000 # number of samples (experiments)
# sampling distribution of the mean
dist.samp <- apply(matrix(rnorm(n*nsamp), nrow = nsamp), 1, mean)
v <- enframe(dist.samp, name = NULL)
ggplot(v, aes(x = value)) +
geom_histogram(aes(y = ..density..),
bins = 40, colour = "black", fill = "white") +
geom_line(aes(y = ..density.., colour = 'Sampling'), stat = 'density', size = 1) +
scale_colour_manual(name = "Distributions", values = "orange1") +
theme(legend.position = c(0.1, 0.85),
axis.title = element_text(size = 16),
axis.text = element_text(size = 14),
legend.text = element_text(size = 12),
legend.title = element_text(size = 14)
)
# ggsave(filename = './figures/nb4_norm_samp_dist.pdf')
The bootstrap distribution can approximate the sampling distribution very well for n = 100 and nboot = 1000. Comment out set.seed, so that different random numbers are generated each time you run the chunk. What happens for different random samples?
What happens for lower values of n and nboot? What do you conclude?
set.seed(777)
n <- 100 # sample size
samp <- rnorm(n) # create sample from normal population
nboot <- 1000 # number of bootstrap samples
nsamp <- 10000 # number of samples (experiments)
# bootstrap distribution
boot.samp <- apply(matrix(sample(samp, n*nboot, replace = TRUE), nrow = nboot), 1, mean)
# sampling distribution of the mean
dist.samp <- apply(matrix(rnorm(n*nsamp), nrow = nsamp), 1, mean)
v <- enframe(dist.samp, name = NULL)
ggplot(v, aes(x = value)) +
geom_histogram(aes(y = ..density..),
bins = 40, colour = "black", fill = "white") +
geom_line(aes(y = ..density.., colour = 'Sampling'), stat = 'density', size = 1) +
# stat_function(fun = dnorm, aes(colour = 'Normal'),
# args = list(mean = mean(boot.samp), sd = sd(boot.samp)), size = 1) +
geom_line(data = as_tibble(boot.samp),
aes(x = value, y = ..density.., colour = 'Bootstrap'),
stat = 'density', size = 1) +
scale_colour_manual(name = "Distributions", values = c("green4", "orange1")) +
theme(legend.position = c(0.1, 0.85),
axis.title = element_text(size = 16),
axis.text = element_text(size = 14),
legend.text = element_text(size = 12),
legend.title = element_text(size = 14)
)
# ggsave(filename = './figures/nb4_norm_samp_dist_boot.pdf')
set.seed(666)
n <- 100 # sample size
samp <- rnorm(n) # create sample from normal population
nboot <- 1000 # number of bootstrap samples
nsamp <- 10000 # number of samples (experiments)
# bootstrap distribution
boot.samp <- apply(matrix(sample(samp, n*nboot, replace = TRUE), nrow = nboot), 1, mean)
# sampling distribution of the mean
dist.samp <- apply(matrix(rnorm(n*nsamp), nrow = nsamp), 1, mean)
v <- enframe(dist.samp, name = NULL)
ggplot(v, aes(x = value)) +
geom_histogram(aes(y = ..density..),
bins = 40, colour = "black", fill = "white") +
geom_line(aes(y = ..density.., colour = 'Sampling'), stat = 'density', size = 1) +
# stat_function(fun = dnorm, aes(colour = 'Normal'),
# args = list(mean = mean(boot.samp), sd = sd(boot.samp)), size = 1) +
geom_line(data = as_tibble(boot.samp),
aes(x = value, y = ..density.., colour = 'Bootstrap'),
stat = 'density', size = 1) +
scale_colour_manual(name = "Distributions", values = c("green4", "orange1")) +
theme(legend.position = c(0.1, 0.85),
axis.title = element_text(size = 16),
axis.text = element_text(size = 14),
legend.text = element_text(size = 12),
legend.title = element_text(size = 14)
)
# ggsave(filename = './figures/nb4_norm_samp_dist_boot2.pdf')
x <- seq(0, 15, .05)
ggplot(tibble::enframe(x), aes(value)) +
theme_linedraw() +
stat_function(fun = dgamma, args = list(shape = 2, scale = 2), size = 1) +
theme(axis.title = element_text(size = 16),
axis.text = element_text(size = 14))
# ggsave(filename = './figures/nb4_gamma_dist.pdf')
set.seed(777)
n <- 100
gamma_shape <- 2
gamma_scale <- 2
# sample n trials from gamma distribution
samp <- rgamma(n, shape = gamma_shape, scale = gamma_scale)
nboot <- 1000
nsamp <- 10000
# bootstrap distribution
boot.samp <- apply(matrix(sample(samp, n*nboot, replace = TRUE), nrow = nboot), 1, mean)
# sampling distribution of the mean of n trials from gamma distribution
dist.samp <- apply(matrix(rgamma(n*nsamp, shape = gamma_shape, scale = gamma_scale), nrow = nsamp), 1, mean)
v <- enframe(dist.samp, name = NULL)
ggplot(v, aes(x = value)) +
geom_histogram(aes(y = ..density..),
bins = 40, colour = "black", fill = "white") +
geom_line(aes(y = ..density.., colour = 'Sampling'), stat = 'density', size = 1) +
# stat_function(fun = dnorm, aes(colour = 'Normal'),
# args = list(mean = mean(boot.samp), sd = sd(boot.samp)), size = 1) +
geom_line(data = as_tibble(boot.samp),
aes(x = value, y = ..density.., colour = 'Bootstrap'),
stat = 'density', size = 1) +
scale_colour_manual(name = "Distributions", values = c("green4", "orange1")) +
theme(legend.position = c(0.1, 0.85),
axis.title = element_text(size = 16),
axis.text = element_text(size = 14),
legend.text = element_text(size = 12),
legend.title = element_text(size = 14)
)
# ggsave(filename = './figures/nb4_gamma_samp_dist_boot.pdf')
set.seed(666)
n <- 100
gamma_shape <- 2
gamma_scale <- 2
# sample n trials from gamma distribution
samp <- rgamma(n, shape = gamma_shape, scale = gamma_scale)
nboot <- 1000
nsamp <- 10000
# bootstrap distribution
boot.samp <- apply(matrix(sample(samp, n*nboot, replace = TRUE), nrow = nboot), 1, mean)
# sampling distribution of the mean of n trials from gamma distribution
dist.samp <- apply(matrix(rgamma(n*nsamp, shape = gamma_shape, scale = gamma_scale), nrow = nsamp), 1, mean)
v <- enframe(dist.samp, name = NULL)
ggplot(v, aes(x = value)) +
geom_histogram(aes(y = ..density..),
bins = 40, colour = "black", fill = "white") +
geom_line(aes(y = ..density.., colour = 'Sampling'), stat = 'density', size = 1) +
# stat_function(fun = dnorm, aes(colour = 'Normal'),
# args = list(mean = mean(boot.samp), sd = sd(boot.samp)), size = 1) +
geom_line(data = as_tibble(boot.samp),
aes(x = value, y = ..density.., colour = 'Bootstrap'),
stat = 'density', size = 1) +
scale_colour_manual(name = "Distributions", values = c("green4", "orange1")) +
theme(legend.position = c(0.1, 0.85),
axis.title = element_text(size = 16),
axis.text = element_text(size = 14),
legend.text = element_text(size = 12),
legend.title = element_text(size = 14)
)
# ggsave(filename = './figures/nb4_gamma_samp_dist_boot2.pdf')
Guillaume A. Rousselet, 2019, University of Glasgow.


Since my teenage days, I've always loved spending too much time on the computer. After getting my computer science degree,
I realized writing compilers wasn't for me so decided to switch my path to writing/blogging. However, little did I
know at that time, I'll be writing programs for web.
I've got chops in all phases of fullstack development process of an application.
Using technology, I enjoy helping clients and peers save time and money through online services and applications.
I love writing code, front and backend, both for work and fun. Interested in hybrid mobile applications, web-app security,
and microservices.
Other pleasure I find is in reading books!
If you have any questions feel free to reach me below.


treatment patients Blephapad Combo (.) study standard blepharitis meibomian {border-style gland px;} #ffffff;} eyelid eye ocular dysfunction AEs MGD Ophthalmol clinical patient treatments wet compress efficacy using wipes Demodex change oil posterior (%) blepharitis. data greater px; sequential symptoms tea treatment, tree {font-family (.%) Ocular baseline chronic following font-size glands use warm (score Treatment acid associated compliance double; events grading lid mites percentage temperature total treated treatment. trial . ± . Patients Sci Standard Vis aloe, analysis border-color border-width changes closed design effective examination high hyaluronic improvement included plotted reached reported sample scale score solid; study. tear weeks {font-style {font-weight (Visit (min; Clin Meibomian Ophthalmology Ther Tseng adverse anti-inflammatories arm better blepharitis: bold cleansing common conducted controlled courier; daily developed diagram difference distributed dry em; eyelids eyes heat heated however, images improve max: natural number provided pt;} randomized results showed solution surface therapy topical –),


Index
A B C D E F G H I J K L M N O P R S T U V W Y
All Classes|All Packages
All Classes|All Packages
All Classes|All Packages
B
- BaseActions - Class in it.polimi.ingsw.Game.Actions
- BaseActions() - Constructor for class it.polimi.ingsw.Game.Actions.BaseActions
- beginTurn() - Method in interface it.polimi.ingsw.Game.Actions.Actions
-
To be called whenever the caller's turn began.
- beginTurn() - Method in class it.polimi.ingsw.Game.Actions.ActionsDecorator
-
To be called whenever the caller's turn begins.
- beginTurn() - Method in class it.polimi.ingsw.Game.Actions.BaseActions
-
To be called whenever the caller's turn began.
- beginTurn() - Method in class it.polimi.ingsw.Game.Actions.Decorators.CanBuildBeforeMove
- beginTurn() - Method in class it.polimi.ingsw.Game.Actions.Decorators.CanBuildThriceIfGroundLvl
- beginTurn() - Method in class it.polimi.ingsw.Game.Actions.Decorators.CanBuildTwice
- beginTurn() - Method in class it.polimi.ingsw.Game.Actions.Decorators.CanHeadbutt
- beginTurn() - Method in class it.polimi.ingsw.Game.Actions.Decorators.CanMoveTwice
- beginTurn() - Method in class it.polimi.ingsw.Game.Actions.Decorators.MoveInfinitelyOnPerimeter
- BLACK(String) - Static method in class it.polimi.ingsw.Utils.CLIColor
- BLOCKS_NUM_CHOICE - Static variable in class it.polimi.ingsw.Client.JavaFX.Scenes.GameplayScene
- BLUE(String) - Static method in class it.polimi.ingsw.Utils.CLIColor
- Board - Class in it.polimi.ingsw.Game
- Board(int, int, int) - Constructor for class it.polimi.ingsw.Game.Board
-
Create a board object
- BOARD - Static variable in class it.polimi.ingsw.Client.JavaFX.Scenes.GameplayScene
- BOARD_DIM_X_CHOICE - Static variable in class it.polimi.ingsw.Client.JavaFX.Scenes.GameplayScene
- BOARD_DIM_Y_CHOICE - Static variable in class it.polimi.ingsw.Client.JavaFX.Scenes.GameplayScene
- BoardClickListener - Interface in it.polimi.ingsw.Client.JavaFX
- BoardClickState - Interface in it.polimi.ingsw.Client.JavaFX
- BoardUpdateBroadcaster - Interface in it.polimi.ingsw.View.Communication.Broadcasters
- BoardUpdateListener - Interface in it.polimi.ingsw.View.Communication.Listeners
- BoardUpdateMessage - Class in it.polimi.ingsw.View.Communication
- BoardUpdateMessage(Board) - Constructor for class it.polimi.ingsw.View.Communication.BoardUpdateMessage
- BOLD(String) - Static method in class it.polimi.ingsw.Utils.CLIColor
- Build(Player, int, int, int, int, int) - Method in class it.polimi.ingsw.Game.Game
-
Handle a build command
- Build(Player, int, int, int, int, int) - Method in class it.polimi.ingsw.Game.Game.PlayingState
-
Handle a build command during playing phase
- Build(Player, int, int, int, int, int) - Method in interface it.polimi.ingsw.Game.GameState
-
Handle a build command in a specific game phase
- BUILD_BTN - Static variable in class it.polimi.ingsw.Client.JavaFX.Scenes.GameplayScene
- BuildClickState() - Constructor for class it.polimi.ingsw.Client.JavaFX.GUI.BuildClickState
- BuildCommandMessage - Class in it.polimi.ingsw.View.Communication
- BuildCommandMessage(int, int, int, int, int) - Constructor for class it.polimi.ingsw.View.Communication.BuildCommandMessage
- buildDome() - Method in class it.polimi.ingsw.Game.Tile
-
Builds a dome on top of the building
- BUILDS_BOX - Static variable in class it.polimi.ingsw.Client.JavaFX.Scenes.GameplayScene
- buildUp() - Method in class it.polimi.ingsw.Game.Tile
-
Builds a level on the given tile, effectively increasing its height by one, or building a dome if needed.
All Classes|All Packages


We are a global non-profit organisation which was founded in January, 2020 in India.
Today, it is working alongside India's leading independent child rights NGOs. As of now,
we plan to cover all 29 states of India.
CharitAble India believes that every child deserves the best chance for a bright future and
that’s why we are fiercely committed towards ensuring that children not only survive, but thrive.
We run programmes in the remotest corners of India and urban areas to provide quality education and
healthcare, protection from harm and abuse and life-saving aid during emergencies to children.
Globally, CharitAble is present in more than 80 countries and works to improve the lives of the most
vulnerable children living there.
Children are our most valuable assets and deserve all the support and protection we can provide them.
Bold in our ambition and powerful in our care, we do whatever it takes to save the world’s children.
In India and around the world, CharitAble India is on the ground – every day and in times of crisis.
Our pioneering programmes address children’s unique needs, giving them a healthy start, the opportunity
to learn and protection from harm. When crisis strikes, we are always among the first to respond and the
last to leave. We are outspoken champions for children, ensuring their voices are heard and their issues
are given top priority. Drawing on a century of leading expertise, we take on the toughest challenges facing
the hardest-to-reach children – especially those unfairly excluded from the world’s progress.
We are proud to be the world’s leading expert on children, delivering lasting results for millions of vulnerable
girls and boys. By saving the world’s children, we transform their lives and the future we share.
Child Labour, Child Refugee Crisis, Child Trafficking, Improper Healthcare and Lack of Education are our prime enemies,
all of which stem from Poverty.
We firmly believe that 'together we can'. So come join us!
- Founder, CharitAble India


inspire Cloud
Home
About
Lorem ipsum, dolor sit amet consectetur adipisicing elit. Sequi, deleniti.
Read More


Further Math Tools
Number Theory
Greatest Common Divisor
Diophantine Equations
Simultaneous Congruences
Polynomial Roots
Graph Theory
Undirected Graphs
Directed Graphs
Developed and maintained by Hanzhi Zhou, licensed under the
MIT license
Click
here
to download the source code


TDSLoader Class
Autodesk 3DS threee.js file loader, based on lib3ds.
Loads geometry with uv and materials basic properties with texture support.
Constructor
TDSLoader
-
manager
Parameters:
-
manager
LoadingManagerLoading manager.
Item Index
Methods
debugMessage
-
message
Print debug message to the console.
Is controlled by a flag to show or hide debug messages.
Parameters:
-
message
ObjectDebug message to print to the console.
endChunk
-
chunk
Set position to the end of the current chunk of data.
Parameters:
-
chunk
ObjectData chunk.
load
-
url
-
onLoad
-
onProgress
-
onError
Load 3ds file from url.
Parameters:
-
url
typeURL for the file.
-
onLoad
FunctiononLoad callback, receives group Object3D as argument.
-
onProgress
FunctiononProgress callback.
-
onError
FunctiononError callback.
nextChunk
-
data
-
chunk
Move to the next data chunk.
Parameters:
-
data
DataViewDataview.
-
chunk
ObjectData chunk.
parse
-
arraybuffer
-
path
Parse arraybuffer data and load 3ds file.
Parameters:
-
arraybuffer
ArrayBufferArraybuffer data to be loaded.
-
path
StringPath for external resources.
Returns:
Group loaded from 3ds file.
readByte
-
data
Read byte value.
Parameters:
-
data
DataViewDataview to read data from.
Returns:
Data read from the dataview.
readChunk
-
data
Read next chunk of data.
Parameters:
-
data
DataViewDataview.
Returns:
Chunk of data read.
readColor
-
data
Read a color value.
Parameters:
-
data
DataViewDataview.
Returns:
Color value read..
readDWord
-
data
Read 64 bit unsigned integer value.
Parameters:
-
data
DataViewDataview to read data from.
Returns:
Data read from the dataview.
readFaceArray
-
data
-
mesh
Read face array data chunk.
Parameters:
-
data
DataviewDataview in use.
-
mesh
MeshMesh to be filled with the data read.
readFile
-
arraybuffer
Decode file content to read 3ds data.
Parameters:
-
arraybuffer
ArrayBufferArraybuffer data to be loaded.
readFloat
-
data
Read 32 bit float value.
Parameters:
-
data
DataViewDataview to read data from.
Returns:
Data read from the dataview.
readInt
-
data
Read 32 bit signed integer value.
Parameters:
-
data
DataViewDataview to read data from.
Returns:
Data read from the dataview.
readMap
-
data
Read texture map data chunk.
Parameters:
-
data
DataviewDataview in use.
Returns:
Texture read from this data chunk.
readMaterialEntry
-
data
Read material data chunk and add it to the material list.
Parameters:
-
data
DataviewDataview in use.
readMaterialGroup
-
data
Read material group data chunk.
Parameters:
-
data
DataviewDataview in use.
Returns:
Object with name and index of the object.
readMesh
-
data
Read mesh data chunk.
Parameters:
-
data
DataviewDataview in use.
readMeshData
-
data
Read mesh data chunk.
Parameters:
-
data
DataviewDataview in use.
readNamedObject
-
data
Read named object chunk.
Parameters:
-
data
DataviewDataview in use.
readShort
-
data
Read 16 bit signed integer value.
Parameters:
-
data
DataViewDataview to read data from.
Returns:
Data read from the dataview.
readString
-
data
-
maxLength
Read string value.
Parameters:
-
data
DataViewDataview to read data from.
-
maxLength
NumberMax size of the string to be read.
Returns:
Data read from the dataview.
readWord
-
data
Read 32 bit unsigned integer value.
Parameters:
-
data
DataViewDataview to read data from.
Returns:
Data read from the dataview.
resetPosition
-
data
Reset dataview position.
Parameters:
-
data
DataViewDataview.
setPath
-
path
Set resource path used to determine the file path to attached resources.
Parameters:
-
path
StringPath to resources.
Returns:
Self for chaining.


| [ Team LiB ] |
|
[SYMBOL]
[A]
[B]
[C]
[D]
[E]
[F]
[G]
[H]
[I]
[J]
[K]
[L]
[M]
[N]
[O]
[P]
[Q]
[R]
[S]
[T]
[U]
[V]
[W]
[X]
[Y]
[Z]
Kay, Alan KDE 2nd 3rd 4th 5th keeper Kernighan, Brian 2nd 3rd 4th Kernighan, Brian W. 2nd 3rd Khosla, Vinod KISS 2nd 3rd kmail 2nd 3rd Knuth, Donald E. 2nd 3rd 4th Korn shell 2nd 3rd Korn, David 2nd 3rd 4th ksh |
| [ Team LiB ] |