Warning :)
PolyChrome is still in an early stage of development. Hopefully, one day it will be polished at least a bit more. For now, as you'll see in the documentation and the code, some things are not as nice or as clear as they could be, but you're welcome to contribute with comments, ideas or code.
Also, this documentation is not yet exhaustive, and we about quite a few issues already :)
Updating the extension
As of now, the extension has not been reviewed by Mozilla, therefore no updates of the extension will be automatically pushed to your browser. You'll have to manually check for new versions of the extension at https://addons.mozilla.org/en-US/firefox/addon/271847/.
Installation
To use the PolyChrome extension you'll need to install PolyML and the PolyChrome extension itself.
Test It
After you've done that, you can check whether it's working by opening up Firefox, right clicking the extension icon at the bottom right corner of the browser and clicking Start PolyML.
The label should change to Initializing.... This means that the neccessary heaps are being built for the first time. After the label changes to PolyML as in the screenshot below try entering some Standard ML code into the console (if you can't see the console click on the PolyChrome icon).
Troubleshooting
If some of the above steps did not work, please refer to the Troubleshooting section
User Interface
You've seen most of what you need to know already and you'll see the rest as you go, but a few quick additional snippets of information in case you find this confusing.
- this icon means that PolyML is not active for this document and no Standard ML code found on this page will be executed.
- this icon means that PolyML is active for this document.
Note that by default, PolyML will never be active for documents containing no SML code. For documents containing SML code, the behavior depends on the Always Enable setting.
Also note that once you've enabled PolyML for a certain tab containing SML code, it will remain enabled until you close the tab or stop PolyML via the context menu.
Hello World
This example will demonstrate how to write SML applications using the PolyChrome.
1.
First, create an empty document called hello.html. Paste the following code into the document, and open the document with Firefox.
<!DOCTYPE html>   <title>Hello SML World</title>

 <canvas id="paper"></canvas>
2.
That's it!
What happened here?
At first, Firefox rendered the HTML document, which is simply a blank page, because it contains an empty h1 element and an empty canvas element. Then, PolyChrome extension found the PolyML code on this page and executed it. The code used DOM library to select the h1 element and add some text into it and then used Canvas library to draw a rectangle in the canvas element.
To fully understand the above example you should be familiar with HTML and JavaScript. Even though, no JavaScript was written in this example, the usage of DOM and Canvas libraries very closely corresponds to the way you would write JavaScript. For instance, lets look at equivalent SML and JavaScript code side by side:
| Standard ML |
DOM.getElementById DOM.document "hello" |
| JavaScript |
document.getElementById("hello") |
| Remarks |
| DOM.getElementById returns an option type, which is NONE if the element does not exist in the document. JavaScript returns null in such case. |
| Standard ML |
DOM.setInnerHTML hello_div "Hello Graphical SML World" |
| JavaScript |
hello_div.innerHTML = "Hello Graphical SML World" |
| Remarks |
| Notice that in case of JavaScript, innerHTML is not a function but rather an attribute. Such attributes can be accessed using the setters and getters provided in the SML DOM library. |
| Standard ML |
Canvas.fillRect context 10 10 30 50 |
| JavaScript |
context.fillRect(10,10,30,50) |
| Remarks |
| In case of SML we pass the context object to a function, whereas in JS we call the method of the object itself. |
Demos
A good way of trying out the extension is checking out the demos that can be opened via the context menu of the extension or by opening chrome://polychrome/content/demos/index.html (note that this link will only work in Firefox with PolyChrome installed).
These demos are not intended to be polished applications. They were created for a proof-of-concept reasons. Some of them, in fact, demonstrate the limitations of the extension.
Troubleshooting
Here are a few things you could take a look at to help in identifying some of the problems.
PolyML Not found
If PolyML is not installed or found on the machine, you will see this.
Click on the icon to go to settings of the extension and configure the path to your PolyML installation.
JavaScript Error Console
PolyChrome extension uses Firefox'es JavaScript Error Console, that can be opened by Tools > Error Console or by Ctrl-Shift-J. Note, that errors from all Firefox extensions or even websites are printed here, so not all of it may be reported by PolyChrome. Only JavaScript components of the extension will report errors here.
stdout
Currently, not all of the PolyML output is printed to the PolyML console in Firefox. Some of it goes to the stdout, that can be seen, for example, by opening Firefox from a terminal (e.g. on linux that would mean executing command "firefox" in the terminal)
Rebuilding Heaps
You'll find the "Rebuild Heaps" button in the settings page, in case that is your problem. For example, this could be needed if you updated the version of PolyML on your machine.
Architecture
To understand the limitations and potential applications of the PolyChrome extension, it is important to have some insight on how it works
Firefox
Firefox browser is as a collection of HTML rendering engine, DOM, JavaScript engine, networking components and many other components. When you enter a URL into the address bar and press enter, Firefox loads an HTML document from the server (or local filesystem), parses it into a Document Object Model (DOM), renders it on the screen and executes the JavaScript code embedded in the HTML document. JavaScript can modify how the document is rendered on screen and react to various user interaction events like mouse clicks and keyboard presses. DOM, which is the in memory representation of HTML, is reflected into JavaScript as a JavaScript object. Calling methods and modifying attributes of this DOM-JavaScript wrapper object affects the DOM and the way it is rendered to the user.
PolyChrome
After the document is loaded, parsed and rendered, PolyChrome looks at the DOM to see if the document contains any script tags with PolyML code. If that's the case a PolyML process is started specifically for this document. A socket communication is established between the JavaScript components and PolyML components. The code that was found on the page is sent through the socket to PolyML for evaluation.
JS FFI
Because we have this connection between JavaScript and PolyML and because JavaScript has access to DOM, we can now ask JavaScript to modify the DOM from within SML.
Read more about the FFI in section Using JavaScript FFI and read the next section to see what are the implications of using this socket-based-foreign-function-interface.
PolyChrome Components
Below is a rough scheme of the PolyChrome components and their relationships.
Additional References
MSc thesis on PolyChrome: http://www.inf.ed.ac.uk/publications/thesis/online/IM100814.pdf
Memory Sharing
DOM elements (e.g., input fields, buttons, paragraphs, images) appear in JavaScript as JavaScript objects. To work with these objects need to be able to store them and access their methods and attributes from within SML.
For example, every time, you call a DOM function that returns an HTML element, e.g.:
val getElementById : Document -> string -> HTMLElement option
you are actually only getting a unique string identifier of this element. That is, JavaScript keeps track of all these objects that SML had interest in, by storing (string identifier, reference to the object) tuples. It only sends the string identifier of an object to SML.
If you lose the string identifier in SML, there is no way to get access to a the corresponding DOM or JavaScript object, however the reference remains stored in JavaScript, which could prevent JavaScript garbage collection and in this way leak memory.
Memory Management
To prevent the memory leaking, you will have to clean up any JavaScript references, when you don't need them in SML anymore. To do that you should use the jsffi.Memory structure
signature JSFFI = sig ... (* these are used for keeping the temporary memory, used for storing javascript objects, tidy *) structure Memory : sig val switchNs : string -> unit val switchDefaultNs : unit -> unit val addFunctionReference : string -> fptr val addFunctionReferenceOW : string -> fptr val removeReference : string -> unit val deleteNs : string -> unit val clearNs : string -> unit val clearDefaultNs : unit -> unit end ... end
For example:
val a = valOf (DOM.getElementById DOM.document "test") (* if the value is not going to be ever used anymore *) val _ = jsffi.removeReference a
Namespacing
It might be cumbersome to keep track of all these references individually. For convenience, you can use the "namespacing" functionality.
(* we'll be using this value throughout the lifetime of the application *) val permanent = valOf (DOM.getElementById DOM.document "permanent") fun temporary () = let val _ = jsffi.switchNs "temp" val temp1 = valOf (DOM.getElementById DOM.document "temp1") val temp2 = valOf (DOM.parent temp1) val temp3 = valOf (DOM.lastChild temp2) (* you can still access the "permanent" element here *) val _ = DOM.setValue temp3 (DOM.getValue permanent) val _ = jsffi.deleteNs "temp" in () end
Persistance
Currently, you can add a "persist" class to the script tags of your PolyChrome application, to tell the extension not to remove the sandbox directory of the application
For example, you can include your application in the document like this:

Then, your included application can create some files on the disk. The next time you open this application in the browser, those files can still be accessed by the application.
If you include multiple scripts, it's enough to add "persist" class to one of them as the persistant storage is provided to the application based on the document url.
Your PolyChrome application starts in the root of this persistant storage directory.
In the Settings page you can clear the persistant data of all applications. To delete data per application basis you'll have to do that manually by browsing to<EMAIL_ADDRESS>It would be nice in the future to explore the HTML5 local storage capabilities, perhaps combine it with the file storage.
Using JavaScript FFI
PolyChrome can execute any Standard ML code. However, the HTML/DOM interaction is limited by what is provided in the DOM and Canvas libraries. Currently these 2 libraries don't provide much functionality and they will have to be extended in order to do something useful.
It is easy to extend the libraries or implement wrappers for any other existing JavaScript libraries, by using the JavaScript Foreign Function Interface (jsffi structure). In the demos page you'll find examples of jQuery and Raphael JavaScript libraries being used from SML.
jsffi
There are currently 4 functions that you can use to interact with JavaScript
signature JSFFI = sig ... (* these are used to call JS functions when using exec_js_r, it is up to the implementation of the wrapper function to convert the returned string to an appropriate type *) (* args: an fptr to an object, a function name, an argument list *) (* e.g. exec_js_r "document|" "getElementById" [arg.string "something"] *) val exec_js_r : string -> string -> JSON.T list list -> string val exec_js : string -> string -> JSON.T list list -> unit val exec_js_get : string -> string -> JSON.T list list -> string val exec_js_set : string -> string -> JSON.T list list -> unit ... end
exec_js_r and exec_js are used to call JavaScript functions. The former expects something returned and the latter does not. They take 3 arguments. An object whose method will be called, a name of the method and a list of arguments.exec_js_get and exec_js_set are similar, but instead of calling methods they get and set attributes of the object.
To start with, you can use two fptr - "window|" and "document|". The foreign pointers are simply strings of this form "identifier|namespace". Window object in the browser is the root, global, ultimate object in the browser. Any JavaScript variable or function that is created in global scope becomes an attribute of the window object. Even the document object can be accessed using the window object fptr.
exec_js_get "window|" "document" []; val it = "0|": string
Now, the fptrs "0|" and "document|" point to the same JavaScript object. Both of them can now be used as the first arguments to the exec_js functions.
For example, to call the getElementById function, we do:
fun parse_element e = case e of "null" => NONE | x => SOME (HTMLElement x) fun getElementById (Document d) id = parse_element (exec_js_r d "getElementById" [arg.string id])
For example, to use the Raphael library, we can do this:
...   ...
Accessing Deeper Attributes of JavaScript Objects
Javascript
Raphael.getColor()
is equivalent to JavaScript
window.Raphael.getColor()
which in SML can be achieved by
exec_js_r "window|" "Raphael.getColor" []
Callbacks
Sometimes you need JavaScript to be able to reference PolyML memory. One of such cases is DOM events. To handle DOM events, the JavaScript FFI is used to add event listeners, but there has to be a way for the JavaScript event handler to call PolyML functions. This is currently quite cumbersome as it involves maintaining data structures to store the PolyML functions for later use. In the future, it would be nice to have this integrated in the jsffi structure.
Below is an implementation of DOM.addEventListener
structure DOM : DOM = struct local open jsffi in ... datatype EventListener = EventListener of string; datatype Event = Event of fptr datatype EventType = click | change | keypress | keyup | mouseover | mouseout | mousemove datatype EventCallback = EventCallback of Event -> unit (* we'll keep event callbacks here *) val eventCallbackTab = ref (Tab.empty : (HTMLElement * EventType * EventCallback) Tab.T) fun handle_event id event = let val (_, _, EventCallback f) = (Tab.get (!eventCallbackTab) (Name.mk id)) handle UNDEF => (raise Error ()) val _ = f (Event event) val _ = Memory.removeReference event (* clean up the memory *) val _ = ready () in () end ... fun addEventListener_ (HTMLElement e) et f add_function_reference = let val callback = "val _ = DOM.handle_event {id} {arg} ;" val id = add_function_reference callback val entry = (HTMLElement e, et, f) val _ = (eventCallbackTab := Tab.ins (Name.mk id, entry) (!eventCallbackTab)) val _ = exec_js e "addEventListener" [arg.string (string_of_eventtype et), arg.reference id, arg.bool false] in EventListener id end fun addEventListener e et f = addEventListener_ e et f Memory.addFunctionReference fun addEventListenerOW e et f = addEventListener_ e et f Memory.addFunctionReferenceOW fun removeEventListener (EventListener id) = let val (HTMLElement e, et, _) = (Tab.get (!eventCallbackTab) (Name.mk id)) handle UNDEF => (raise PolyChrome.DOMExn "Undefined listener"); val _ = (eventCallbackTab := (Tab.delete (Name.mk id) (!eventCallbackTab))) val _ = exec_js e "removeEventListener" [arg.string (string_of_eventtype et), arg.reference id, arg.bool false] val _ = Memory.removeReference id in () end ... end end
Comments
We store the HTML element, event type and event callback function to the eventCallbackTab table. We need this table to be able to call the function anytime the event fires. The event type and the HTML element has to be stored, because that information is needed when we want to remove the event listener.
add_function_reference is used to create a JavaScript function, that when called, sends a string to PolyML, in this case "val _ = DOM.handle_event {id} {arg} ;", for evaluation. This way we can create a JavaScript function that can call an SML function. The obscure {id} bit is replaced by JavaScript with the string identifier of that JavaScript function. It is the same identifier that is used for all JavaScript objects that are shared between JavaScript and PolyML as discussed in the Memory Sharing section. Each of the following {arg} substrings are replaced with the argument that the JavaScript function was called with. For example, in this case, all callbacks passed to the window.document.addEventListener function are called with an event object, which in this case is going to be passed to the SML function as an argument (again, only the string identifier will be passed to SML).
The difference between Memory.addFunctionReference and Memory.addFunctionReferenceOW is that the latter can be used in case of rapidly firing events. All of the callbacks that are called using the mechanism described above are queued up in JavaScript. If, for example, you listen to the mousemove event, moving the mouse will queue up a lot of these event callbacks. If Memory.addFunctionReferenceOW is used, where OW stands for OverWritable, then only the last function call in the queue will be called when PolyML is ready to handle more events. By the way, that is what jsffi.ready() is needed for. It tells JavaScript that PolyML is ready to handle more events and the next callback from the queue is dispatched to PolyML.
To fully understand what's going on in here you will have to look at the implementation of jsffi in both SML and JS. Those can be found in jsffi.sml and JSFFI.js files.
DOM signature
signature DOM = sig datatype Event = Event of jsffi.fptr datatype Window = Window of jsffi.fptr datatype EventListener = EventListener of string datatype HTMLElement = HTMLElement of jsffi.fptr datatype Timeout = Timeout of string datatype Interval = Interval of string datatype TimerCallback = TimerCallback of unit -> unit datatype EventType = change | click | keypress | keyup | mousemove | mouseout | mouseover datatype HTMLCollection = HTMLCollection of jsffi.fptr datatype EventCallback = EventCallback of Event -> unit datatype Document = Document of jsffi.fptr val document : Document val window : Window val fptr_of_HTMLElement : HTMLElement -> jsffi.fptr val string_of_eventtype : EventType -> string val parse_element : string -> HTMLElement option val parse_element_list : string -> HTMLElement list val getElementById : Document -> string -> HTMLElement option val getElementsByTagName : Document -> string -> HTMLCollection val parentNode : HTMLElement -> HTMLElement option val lastChild : HTMLElement -> HTMLElement option val removeChild : HTMLElement -> HTMLElement -> unit val previousSibling : HTMLElement -> HTMLElement option val getStyle : HTMLElement -> string -> string val replaceChild : HTMLElement -> HTMLElement -> HTMLElement -> unit val nextSibling : HTMLElement -> HTMLElement option val setStyle : HTMLElement -> string * string -> unit val firstChild : HTMLElement -> HTMLElement option val appendChild : HTMLElement -> HTMLElement -> unit val childNodes : HTMLElement -> HTMLElement list val createElement : Document -> string -> HTMLElement val createTextNode : Document -> string -> HTMLElement val getAttribute : HTMLElement -> string -> string val setAttribute : HTMLElement -> string * string -> unit val removeAttribute : HTMLElement -> string -> unit val getInnerHTML : HTMLElement -> string val setInnerHTML : HTMLElement -> string -> unit val getValue : HTMLElement -> string val setValue : HTMLElement -> string -> unit val getHTMLCollectionItem : HTMLCollection -> int -> HTMLElement val addEventListener : HTMLElement -> EventType -> EventCallback -> EventListener val addEventListenerOW : HTMLElement -> EventType -> EventCallback -> EventListener val removeEventListener : EventListener -> unit val setInterval : Window -> TimerCallback -> int -> Timeout val clearInterval : Window -> Interval -> unit val setTimeout : Window -> TimerCallback -> int -> Timeout val clearTimeout : Window -> Timeout -> unit val handle_event : string -> jsffi.fptr -> unit val handle_interval : string -> unit val handle_timeout : string -> unit val getClientX : Event -> int val getClientY : Event -> int val alert : Window -> string -> unit end
Canvas Signature
signature CANVAS = sig datatype Context = Context of jsffi.fptr val getContext : DOM.HTMLElement -> string -> Context val stroke : Context -> unit val fillRect : Context -> int -> int -> int -> int -> unit val moveTo : Context -> int -> int -> unit val fill : Context -> unit val lineTo : Context -> int -> int -> unit val getStrokeStyle : Context -> string val beginPath : Context -> unit val fillStyle : Context -> string -> unit val getFillStyle : Context -> string val canvasHeight : Context -> int val arc : Context -> int -> int -> real -> real -> real -> bool -> unit val getLineWidth : Context -> string val canvasWidth : Context -> int val setStrokeStyle : Context -> string -> unit val setFillStyle : Context -> string -> unit val setLineWidth : Context -> real -> unit end
JSON Signature
signature JSON = sig exception notobj_exn of unit structure Tab : NAME_TAB structure Name : SSTR_NAMES datatype T = Bool of bool | Int of int | List of T list | Null | Object of T Tab.T | Real of real | String of string val empty : T val update : string * T -> T -> T val add : string * T -> T -> T val lookup : T -> string -> T option val get : T -> string -> T val delete : string -> T -> T val encode : T -> string end
JSFFI Signature
signature JSFFI = sig type fptr exception Error of unit structure Tab : NAME_TAB structure Name : SSTR_NAMES (* this is used in combination with the exec_js_r and exec_js*) structure arg : sig val string : string -> JSON.T list val reference : fptr -> JSON.T list val real : real -> JSON.T list val object : JSON.T -> JSON.T list val null : unit -> JSON.T list val list : JSON.T list -> JSON.T list val int : int -> JSON.T list val callback : string -> JSON.T list val bool : bool -> JSON.T list end (* these are used to call JS functions when using exec_js_r, it is up to the implementation of the wrapper function to convert the returned string to an appropriate type *) (* args: an fptr to an object, a function name, an argument list *) (* e.g. exec_js_r "document|" "getElementById" [arg.string "something"] *) val exec_js_r : string -> string -> JSON.T list list -> string val exec_js : string -> string -> JSON.T list list -> unit val exec_js_get : string -> string -> JSON.T list list -> string val exec_js_set : string -> string -> JSON.T list list -> unit (* this must be called after handling each event *) val ready : unit -> unit (* these are used for keeping the temporary memory, used for storing javascript objects, tidy *) structure Memory : sig val switchNs : string -> unit val switchDefaultNs : unit -> unit val addFunctionReference : string -> fptr val addFunctionReferenceOW : string -> fptr val removeReference : string -> unit val deleteNs : string -> unit val clearNs : string -> unit val clearDefaultNs : unit -> unit end end
Development Guide
The source code and the bug tracker can be found at https://github.com/KidkArolis/PolyChrome.
Setting Up the Development Environment
Firefox extension is a zip archive with all of the extension files (with an extension .xpi), that is extracted to your Firefox profile once you install it. You could browse to your firefox profile and modify the code of the extension there, but there is a much better way of working on the code of the extension. Clone or fork the repository and create a "symlink" in your Firefox profile, pointing to the repo. Note, that this symlink is not a symlink in a usual sense, it is just a text file with a path to the extension. The simplest way of doing this is using the deploy script that you'll find in the root dir of the repo.
To use the deploy script you'll first need to create a deploy.cfg file based on the deploy.cfg.template
After that, simply executing
# ./deploy run
will place a text file in your Firefox profile with the path to the source code of the extension and will immediately run Firefox (with the error console opened up). After running the deploy script once, Firefox will always load the extension from your repository. However, you do need to restart the Firefox browser every time you modify the JavaScript components of the extension or overlays/styles, etc. If you can't see some changes that you expect to see after restarting Firefox, you might want to run the deploy script again, because it clears the extension registry/cache. To remove the extension, you can simply uninstall it via the Add-Wons manager in Firefox
Modifying SML components requires only the refresh of the HTML document. When extension is loaded using this "symlink", the extension knows it's running in development mode (function Utils.isDevelopmentMode) and therefore recompiles the SML components every time a document is opened.
Also, you should take a look at https://developer.mozilla.org/en/setting_up_extension_development_environment, especially the "Development preferences".
In general https://developer.mozilla.org/ is the place to look for all of the extension development related docs.
Packaging
Executing
# ./deploy package
will zip the neccessary files and create an .xpi file.
File Structure
/polychrome/chrome/content/core - contains the JavaScript components of the extension. Their relationships can be seen in the Architecture section
/polychrome/chrome/content/core/PolyChrome.js - is the entry script. PolyChrome.init function, called in the ff-overlay.xul, starts the magic.
/polychrome/chrome/content/ff-overlay.js - describes the GUI of the extension.
/polychrome/chrome/content/docs - contains this documentation that you're reading right now. A copy of this directory is placed in the "gh-pages" branch of the repo for online access via GitHub pages.
/polychrome/chrome/content/demos - contains all of the demos.
/polychrome/poly - contains the SML components of the extension.
/polychrome/poly/main.sml - is the entry script of the PolyML side of things. PolyChrome.main is the initialization function called in the polyml.sh bash script (that is executed in JavaScript).
/polychrome/poly/bin - contains some bash scripts for finding PolyML binary on the clients machine, running the main.sml script, and killing the PolyML process. This is the only bit of the whole extension that prevents it to be truly cross-platform. Hopefully, with some modifications in the next release of PolyML, these scripts won't be neccessary anymore.
/polychrome/poly/isaplib/ - contains the isaplib library that is used by the extension. Isaplib is part of the IsaPlanner
/polychrome/sandboxes/ - is used to store all temporary files downloaded from the server (when they're included using script tags).
Read https://developer.mozilla.org/en/building_an_extension for description of the other, Firefox specific, files, such as install manifest.


Contact Kathy!
Home
About
Services
Portfolio
Contact
Contact me via social media or use the form.
Note: all fields are required. Thank you!


Uptown funk you up


Cartogram heatmaps are an alternative to choropleth maps for USA States and are based on work by the Washington Post graphics department in their report on "The states most threatened by trade". "State bins" preserve as much of the geographic placement of the states as possible but has the look and feel of a traditional heatmap. Functions are provided that allow for use of a binned, discrete scale, a continuous scale or manually specified colors depending on what is needed for the underlying data.
| Version: | 1.2.2 |
| Depends: | R (≥ 3.0.0) |
| Imports: | ggplot2, grid, gridExtra, scales, RColorBrewer |
| Suggests: | testthat |
| Published: | 2015-12-21 |
| Author: | Bob Rudis (@hrbrmstr) |
| Maintainer: | Bob Rudis <bob at rudis.net> |
| BugReports: | https://github.com/hrbrmstr/statebins/issues |
| License: | MIT + file LICENSE |
| URL: | http://github.com/hrbrmstr/statebins |
| NeedsCompilation: | no |
| In views: | Spatial |
| CRAN checks: | statebins results |
| Reference manual: | statebins.pdf |
| Package source: | statebins_1.2.2.tar.gz |
| Windows binaries: | r-devel: statebins_1.2.2.zip, r-release: statebins_1.2.2.zip, r-oldrel: statebins_1.2.2.zip |
| OS X binaries: | r-release: statebins_1.2.2.tgz, r-oldrel: statebins_1.2.2.tgz |
| Old sources: | statebins archive |
Please use the canonical form https://CRAN.R-project.org/package=statebins to link to this page.


Missing daily rate for budget Implementation of Feature XYZ between 01.01.2014 and 31.12.2014
Missing daily rate for budget Project Management between 01.01.2014 and 31.12.2014
The full name of the person as it should be displayed in the dashboard.
The unique key that identifies this person when importing data.
Define daily rates for different budgets and different date ranges in the table below.


By allowing digital information to be distributed but not copied, blockchain technology created the backbone of a new type of internet. Originally devised for the digital currency, Bitcoin, the tech community has now found other potential uses for the technology.
A blockchain is, in the simplest of terms, a time-stamped series of immutable record of data that is managed by cluster of computers not owned by any single entity. Each of these blocks of data (i.e. block) are secured and bound to each other using cryptographic principles (i.e. chain).
For more information on Blockchain click here


Last week I was working on implementing parallel cholesky factorization on accelerators, using SYCL DPC++, though obtained
performance was not impressive due to some points I recognized and noted here.
Today I plan to expand on those points, while splitting factorization into computationally ordered and dependent steps, which eventually proves to
attain better speed up than previous implementation of mine.
I abstractly start working with one symmetric positive definite square matrix AN x N, which I convert into UN x N. Obtaining the other
half is as easy as performing a transpose of UN x N, giving me LN x N.
Once both of these halves are computed, 👇 can be checked, while keeping it in mind that as these computations are performed on accelerated
environments, some floating point errors are inevitable.
I begin with an easy step, where I first initialise UN x N with AN x N and then parallelly zero out lower triangular portion ( read cells below pivots ) of UN x N. During the further course
of computation I'll never need to access those memory locations. As lower triangular portion of matrix is not rectangular shaped, I have to
spawn N x N parallel work-items to zero out cells below pivots, though a substantial number of work-items will do nothing useful,
which I ensure using conditional statement --- sadly resulting into divergent control flow.
I write the respective kernel as 👇
Next I've to run through a set of steps for N-many rounds, as matrix dimension is N x N. During each round, I go through following 2 steps of computations, in-order, as they have computational dependency.
Actually during each of these N-rounds, a pivot is selected and all operations are performed around it. These operations only compute/ access cells above (or including)
pivots i.e. upper triangular portion of matrix.
In first step of round-k, say pivot Uk, k is selected, all I do is atomically compute updated pivot value by subtracting squared values at cells Ui, k
where 0 <= i < k. Primarily I spawned N x N work-items for this step and was using conditional statements
so that only work-items representing cells above selected pivot are able to atomically update pivot, by subtracting squared value of self. But this
results into divergent control flow, costing high, as most of work-items do nothing useful after work-groups are fetched for computation. But one thing I noticed,
during this step only cells above/ including selected pivot are accessed, which opens up opportunity for only spawning k
work-items, parallelly (and atomically) computing updated value of selected pivot Uk, k.
In following diagram, I depict this step of round-k (= 2), by only spawning k(= 2) work-items, atomically computing selected pivot U2, 2,
by subtracting Ui, 22, where i = {0, 1}.
Before step one is completed, I've to spawn another kernel, for computing a single cell of UN x N, by performing square root of selected pivot Uk, k. It's easy and cheap to spawn a kernel, which accesses single pivot cell and computes updated value, rather than implicitly transferring matrix data to host; computing same and finally again implicitly transferring data back to device. Data movement is expensive, costs lots of computation cycles and I aim to minimize so, which is why for improving performance I decide to spawn a single task kernel, which just updates selected pivot on device, while fully avoiding data movement --- low cost !
In second step, I compute updated values of cells, living on selected pivot row ( i.e. Ak, _ ), to be more specific
only those rightwards from pivot cell Ak, k. During this step, I need to access cells from a submatrix of dimension
(k + 1) x (N - k). Following same logic as mentioned before, I decide to only spawn N - (k + 1)
work-items, which removes need for using conditional statements, required when spawning N x N work-items, resulting into
most work-items sitting idle. Notice, for any selected k ( >= 0 && < N ), only N - (k + 1) columns have column index
higher than selected pivot on same row --- so this time no divergence in control flow, all work-items do something useful.
In following depiction, I use k = 1 i.e. in round-1 of cholesky factorization, I compute N - (k + 1) = 2 cells on pivot row i.e. U1, i where i = {2, 3}, while
accessing cells from marked submatrix. You may want to take a look at what exactly is computed by each of N - (k+1) work-items
here.
After completion of both steps, in each round, all cells of pivot row Uk, _ hold final value i.e. what it's supposed to be in upper triangular portion after factorization.
And after N-many rounds, upper triangular portion is stored in UN x N.
I decide to run benchmarks on updated cholesky factorization implementation.
Previous implementation on same hardware performed worse for N = 1024, completing in ~400ms, which is now improved to ~370ms. You may also notice, as matrix dimension
keeps increasing, floating point math error also keeps increasing, which is found when comparing LN x N x UN x N with AN x N. As I compile
DPCPP program with -ffast-math option, allowing fast, aggressive, lossy floating point computation, I expect deviation of this scale.
Finally I run improved implementation on another CPU, getting to much better performance of ~172ms of completion time, for N = 1024. Previous unoptimised version on same hardware with same launch configurations resulted into completion time of ~221ms --- ~22% performance boost !
I keep optimised implementation of cholesky factorization here for future reference.
In coming days, I'll take up other problems for solving them on accelerated environments, as I generally do.
Have a great time !


CRONOS A Film Review by Scott Renshaw Copyright 1994 Scott Renshaw
Starring: Federico Luppi, Ron Perlman, Claudio Brook, Tamara Shanath, Margarita Isabel. Screenplay/Director: Guillermo del Toro.
Horror films with any semblance of wit or style are so rare that I'm tempted to be even warmer in my embrace of CRONOS than my head tells me to be. This Mexican import puts a unique spin on its tale of a search for eternal life, features some extremely arresting imagery and has a nicely twisted sense of humor. Yet as much as I admired the artistry of CRONOS, I couldn't help but notice a gaping hole at the center, namely a central character who steadfastly refused to engender any sympathy. A viewer willing to overlook its lack of heart will be rewarded by a project full of a new director's excitement at being allowed to realize his vision.
CRONOS opens with a narration describing the efforts of a 14th century alchemist to find the secret to eternal life. In our own time, that secret has fallen into the hands of antique dealer Jesus Gris (Federico Luppi), in the form of a mysterious golden egg called the cronos device. After unwittingly activating it, a change begins to come over Jesus which worries his granddaughter Aurora (Tamara Shanath). And his transformation is not the only dilemma facing Jesus. Dying industrialist Dieter de la Guardia (Claudio Brook) also knows of the existence of the cronos device, and wants to use its power to save himself. He sends his brutish American nephew Angel (Ron Perlman), who covets an inheritance from his uncle, to obtain the device--a quest which proves exceedingly difficult.
Thanks to the half-dozen or so credits which precede the title, CRONOS reportedly boasts the second highest budget in Mexican film history (behind only LIKE WATER FOR CHOCOLATE), and Guillermo del Toro leaves it all on the screen. True, the make-up effects seem cheesy by modern standards, but elsewhere CRONOS sports a high polish. The art direction team of Brigitte Broch and Maria Figueroa have created some dynamic sets, most notably Dieter's antiseptic living quarters, filled with dangling statues and jars containing Dieter's excised tumors. Also noteworthy is the cronos device itself, and del Toro's creative use of it, including showing its elaborate inner workings. Director of photography Guillermo Navarro shoots the film with an emphasis on big spaces, and the result is a deliciously spooky atmosphere.
For all its visual flair, CRONOS may be most satisfying on the level of del Toro's off-beat sense of humor. There is a glorious perversity to a scene in which Jesus finds himself inexplicably compelled to perform a unique clean-up job after a gentleman with a nosebleed in a public restroom, and to the image of Aurora clearing out her toybox to serve a purpose for which it probably was never intended. There is also a quirky performance by Daniel Jimenez Cacho as a mortician who takes inordinate pride in his craft, and Ron Perlman (of TV's "Beauty and the Beast") as the slightly dim-witted goon obsessed with getting a nose job. Guillermo del Toro manages to put a lot of bite into his script, in more ways than one.
There is that one big problem, though: Jesus Gris is completely bland. Del Toro doesn't connect Jesus' fate with his character in any noticeable way; in fact, it might be a stretch to say that Jesus has a character. With his ultra-symbolic name, you would assume that there might be some attempt to go deeper into the psychology of his "resurrection." But there is no sense of who he was before his experience with the cronos device, and more early characterization would have been extremely useful. I also had problems with Aurora, whose placid response to bizarre events is stylized but ultimately tedious. Of course, style is ultimately CRONOS' strongest asset, and it's very strong at that.
Guillermo del Toro has said that he only wants to make horror films. With a bit of seasoning as a writer, these projects could prove well worth anticipating for the thinking fright fan.
On the Renshaw scale of 0 to 10 cronos devices: 7.
-- Scott Renshaw Stanford University Office of the General Counsel
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Marco Arment released a new version of Overcast last Friday and I’m impressed with the level of privacy that is possible while still maintaining functionality and a good user experience.
Almost all accounts are now anonymous - meaning that they contain NO user identifiable information. The account that is created doesn’t have a username/email or password. It uses iCloud to get a login token and uses that token to identify and login the account across devices.
The app has the same functionality and the experience is better using login tokens than having to remember yet another account name and password and logging in and setting up 2FA. All of that nonsense just disappears. It’s better for the user because Overcast can’t track the individual. It’s better for Marco because he doesn’t have to manage personal information because their isn’t any to manage.
I look forward to seeing this shift in application design - privacy first design. Designing an application to have privacy first requires a lot of foresight and planning. It is much more difficult to add/remove personal information because it requires changing so many workflows.
I applaud Marco and other developers who are pushing privacy first application design.


This page lists peripheral device types specified in the INQUIRY data. More...
Macros | |
| #define | SBC_DIRECT_ACCESS_BLOCK_DEVICE 0x00 |
| #define | SBC_SEQUENTIAL_ACCESS_DEVICE 0x01 |
| #define | SBC_PRINTER_DEVICE 0x02 |
| #define | SBC_PROCESSOR_DEVICE 0x03 |
| #define | SBC_WRITE_ONCE_DEVICE 0x04 |
| #define | SBC_CD_DVD_DEVICE 0x05 |
| #define | SBC_SCANNER_DEVICE 0x06 |
| #define | SBC_OPTICAL_MEMORY_DEVICE 0x07 |
| #define | SBC_MEDIA_CHANGER_DEVICE 0x08 |
| #define | SBC_COMMUNICATION_DEVICE 0x09 |
| #define | SBC_STORAGE_ARRAY_CONTROLLER_DEVICE 0x0C |
| #define | SBC_ENCLOSURE_SERVICES_DEVICE 0x0D |
| #define | SBC_SIMPLIFIED_DIRECT_ACCESS_DEVICE 0x0E |
| #define | SBC_OPTICAL_CARD_READER_WRITER_DEVICE 0x0F |
| #define | SBC_BRIDGE_CONTROLLER_COMMANDS 0x10 |
| #define | SBC_OBJECT_BASED_STORAGE_DEVICE 0x11 |
This page lists peripheral device types specified in the INQUIRY data.
| #define SBC_BRIDGE_CONTROLLER_COMMANDS 0x10 |
| #define SBC_CD_DVD_DEVICE 0x05 |
| #define SBC_COMMUNICATION_DEVICE 0x09 |
| #define SBC_DIRECT_ACCESS_BLOCK_DEVICE 0x00 |
| #define SBC_ENCLOSURE_SERVICES_DEVICE 0x0D |
| #define SBC_MEDIA_CHANGER_DEVICE 0x08 |
| #define SBC_OBJECT_BASED_STORAGE_DEVICE 0x11 |
| #define SBC_OPTICAL_CARD_READER_WRITER_DEVICE 0x0F |
| #define SBC_OPTICAL_MEMORY_DEVICE 0x07 |
| #define SBC_PRINTER_DEVICE 0x02 |
| #define SBC_PROCESSOR_DEVICE 0x03 |
| #define SBC_SCANNER_DEVICE 0x06 |
| #define SBC_SEQUENTIAL_ACCESS_DEVICE 0x01 |
| #define SBC_SIMPLIFIED_DIRECT_ACCESS_DEVICE 0x0E |
| #define SBC_STORAGE_ARRAY_CONTROLLER_DEVICE 0x0C |
| #define SBC_WRITE_ONCE_DEVICE 0x04 |


| Name: mast virag doshi | Reg No: 16-7-smmhc18 |
|---|---|
| Age / Sex:2.10 years | Contact No:9830660342 |
| Marital Status: | Date:30/7/18 |
| Occupation: | Dr. pjfp |
| Address:native of Calcutta. In blore since may 2018. | DIAGNOSIS- |
Abdomen pain since a week. Potty area biting feeling.
Early in the mng says stomach Is paining imm after getting up. Bloated. As the day wanes he s better.
Cough and cold since coming to blore.
Speech not clear instead of ‘r’ he says ‘l’ . instead of ‘sa’ he says ‘cha’. feels confidence is low mother says with frns he keeps crying and cant communicate. Always says mama u come. Cant go alone. From a week in sleep he is shouting about bhanu mam pls take this n all.
Allergic to mosquitoes.
Extremely dry skin. Allergic to olive oil got rashes after that.
Likes medicines no matter how bitter it is still he eats.
Birth h/o:
Lscs – said no pain so the doc did on the edd.
Past h/o:
10 mnths old had skin problem water was coming out frm skin after scratching himself. No eruptions. Took homoeo but reduced after an year.
Family h./o:
Dad and bro maternal have stammering.
Mind:
Keeps on crying fr everything frm 3-4 months. More close to papa.

Personal h/o:
Doesn’t prefer spicy.
Rx:
Chamomilla1m – 4—4—4-4
Lyco1m – 7 doses – 1 dose alt days.
Disc 4-0-4 a/food.
Tulsi vasaka 1 tsp.
9/8/19: night vomitings. Abdomen pain now and then. Cold and cough not there. Crouches wen abd. And it lasts for 10 min. wen pain in throat he says he cant eat he cant drink.
Rx: -
Ars 1m – 1 dram pills . 4-4-4-4.
Phos1m – 4-4-4-4.
Colo+chamo+merc cor.1m – 4-4-4-4.
16/8/18: imm after eating 5-7 min gets the abd pain. always talks to himself.
Abd pain same. Biting in the anus region.
RX:
Sulphur1m+MERC COR 1M+CHAMOMILLA1M– 4-4-4-4
RUB 15 – 1 DOSE NIGHT B/FOOD.
27/8/18: fever since after coming from school he just sleeps. Feeling weak. Shivering in the afternoon.
Rx:
Bell1m+ cina1m+lyco1m – 6 pills -10 min .
4/1/18: went fr a holiday fr a week. Lot of gas. Releases every 10min. and pain while passing. Took deworming fr 15 days after that till now no stomach issues. Gets potty feeling but wen he goes to the loo he passes only gas. Drinks less water.
Rx:
1.nat sulph 200 – 4-4-4-4
2. pl – 4-4-4-4.


|
HaHa
|
stdlib for HAHA project, contains imports and defines More...
Go to the source code of this file.
Macros | |
| #define | COLORED false /* Set this to false to disable terminal colors. */ |
| #define | DEBUGMES true /* Set this to false to disable debug messages. */ |
| #define | VERBOSEMES true /* Set this to false to disable verbose messages. */ |
| #define | ERRORMES true /* Set this to false to disable error messages. */ |
| #define | CDEF "\033[0m" |
| #define | CRED "\x1B[31m" |
| #define | CGRN "\x1B[32m" |
| #define | CBLU "\x1B[34m" |
| #define | CYEL "\x1B[33m" |
| #define | CMAG "\x1B[35m" |
| #define | CCYN "\x1B[36m" |
| #define | CWHT "\x1B[37m" |
| #define | DEBUG_PRINT true |
| #define | HAHADEBUG(format, args...) printf(format, ## args) |
| #define | printe(...) (void)0; |
| #define | printv(...) (void)0; |
| #define | printd(...) (void)0; |
| #define | MAXFIRSTNAME 17 |
| #define | MAXLASTNAME 17 |
| #define | MAXPHONE 16 |
| #define | MAXHOMEADDR 45 |
| #define | MAXNETADDR 8 |
| #define | MAXPORT 2 |
| #define | START_OPCODE 0x01 |
| #define | MAX_OPCODE 0x0C |
| #define | streq(a, b) !strcmp(a, b) |
Typedefs | |
| typedef uint8_t | opcode |
| typedef uint8_t | ttl |
| typedef uint16_t | uid |
Enumerations | |
| enum | Priority { PRI_OFF = 0, PRI_INFO, PRI_ALERT, PRI_REDALERT } |
Functions | |
| void | delay (uint32_t ms) |
| { Delays execution in ms } More... | |
| void | printBuff (char *data, uint8_t len, char *specifier) |
| { Print a buffer to stdout } More... | |
| uint8_t | asciihex_to_byte (uint8_t d1, uint8_t d2) |
| { Takes two char and converts to Hex } More... | |
| char * | convert_asciihex_to_byte (char *addr) |
| uint64_t | byte_array_to_64 (uint8_t *s) |
| void | addTestUsers () |
Variables | |
| int | toglight |
stdlib for HAHA project, contains imports and defines
| #define CBLU "\x1B[34m" |
| #define CCYN "\x1B[36m" |
| #define CDEF "\033[0m" |
| #define CGRN "\x1B[32m" |
| #define CMAG "\x1B[35m" |
| #define COLORED false /* Set this to false to disable terminal colors. */ |
| #define CRED "\x1B[31m" |
| #define CWHT "\x1B[37m" |
| #define CYEL "\x1B[33m" |
| #define DEBUG_PRINT true |
{ #define for debug printing }
| #define DEBUGMES true /* Set this to false to disable debug messages. */ |
| #define ERRORMES true /* Set this to false to disable error messages. */ |
| #define HAHADEBUG | ( | format, | |
| args... | |||
| ) | printf(format, ## args) |
| #define MAX_OPCODE 0x0C |
| #define MAXFIRSTNAME 17 |
| #define MAXHOMEADDR 45 |
| #define MAXLASTNAME 17 |
| #define MAXNETADDR 8 |
| #define MAXPHONE 16 |
| #define MAXPORT 2 |
| #define printd | ( | ... | ) | (void)0; |
| #define printe | ( | ... | ) | (void)0; |
| #define printv | ( | ... | ) | (void)0; |
| #define START_OPCODE 0x01 |
| #define streq | ( | a, | |
| b | |||
| ) | !strcmp(a, b) |
| #define VERBOSEMES true /* Set this to false to disable verbose messages. */ |
| typedef uint8_t opcode |
| typedef uint8_t ttl |
| typedef uint16_t uid |
| enum Priority |
| void addTestUsers | ( | ) |
| uint8_t asciihex_to_byte | ( | uint8_t | d1, |
| uint8_t | d2 | ||
| ) |
{ Takes two char and converts to Hex }
| [in] | d1 | First ascii character |
| [in] | d2 | Second ascii character |
| uint64_t byte_array_to_64 | ( | uint8_t * | s | ) |
| char* convert_asciihex_to_byte | ( | char * | addr | ) |
| void delay | ( | uint32_t | ms | ) |
{ Delays execution in ms }
| [in] | ms | The milliseconds |
| void printBuff | ( | char * | data, |
| uint8_t | len, | ||
| char * | specifier | ||
| ) |
{ Print a buffer to stdout }
| data | The data | |
| [in] | len | The length |
| specifier | The specifier |
| int toglight |


Drinks
Search from a wide variety of drinks.
Search from a wide variety of drinks.
Stay healthy by knowing the amount of calories in your food.
Find recipes made from organic materials.
Find recipes that contain white meat.
Explore huge variety of sea food.
Search from a variety of different hot & spicy food.
150+
350+
250+
200+


Add Property to Database
Property Added!
Property Category
Select
First Item
Second Item
Third Item
Sell or Rent
Select
Sell
Rent
Block
BHK
Type
Select
First Item
Second Item
Third Item
Floor
Select
First Item
Second Item
Third Item
Furnished or Unfurnished
Select
Furnished
Unfurnished
Area
Price
Property Type
Address
Freehold or Leasehold
Select
Freehold
Leasehold
Unit Number
Locality
Select
First Item
Second Item
Third Item
Description
Owner Name
Owner Number
Partner Name
Add Properties


This site contains an open-source library of AI techniques, written in C++. I write them to skill myself in becoming an AI software developer. I share the code to increase the momentum for using AI techniques in general. I feel much more can be done with AI in real life applications. Also, most of this code I will not use in a commercial setting and I would not like the effort put into it to be wasted. Contents
Code and Documentation
The Source code (in a zip-file). The code consists of a number of small libraries, each one for a technique mentioned below. All code is object oriented. This is because it befits most domains very well. Only when performance would really suffer from a completely OOP implementation, I have decided to use an other datastructure for part of the code. The implementation is driven by three factors: 1) Stay close to the specification of the technique; 2) Architectural elegance; 3) Good performance, in that order. Each small library is based in a Model class, which manages all other objects needed in the domain. In any application, one first sets up the model, then there may be an initialization step, and finally one tells the model to run, or to update itself again and again until some criterion has been met. Finally, I want to mention that I will not hesitate to mention any shortcomings I will find in the specifications of the techniques I use. I will also try to mention the implementation choices I make. And I will mention my own stupidities. All this is meant to bring the subjects to life, to show the creative process of software development. Disclaimer
The material is free to use but not to sell. If you want to use it commercially, ask my permission first. It is not been tested very much, so it may contain errors.
|


This website is made to share the assignments I worked out for statistic courses in the Epidemiology Graduate Program of the Julius Center, Utrecht, the Netherlands
pre-testing and type-I error rates: re-analysis of Rasch
the circle dance: strategy for positioning at equidistance in a group
working directory
Due to how this website was made, the R-code ‘thinks’ it is in the analysis
subdirectory, while the data sits in the data
directory, which is found from the parent directory. Working with Rmarkdown and keeping track of the directory is not too easy at all. After modern methods, I switched to using the package here
, which is specifically designed to target such problems.
Before that I used the function fromParentDir
, which allows you to call files from the parent directory. The function can be found in the package epistats
, which can be installed with devtools::install_github("vanAmsterdam/epistats")
If devtools
is not yet installed, first run install.packages("devtools")
packages and functions
Sometimes different packages provide functions with the same names. To make sure you use the intended function (and to circumvent using library(package)
), use <package>::<function>
to use <function>
from package <package>
, like epistats::fromParentdir
This R Markdown site was created with workflowr


from herschelhelp_internal import git_version
print("This notebook was run with herschelhelp_internal version: \n{}".format(git_version()))
%matplotlib inline
#%config InlineBackend.figure_format = 'svg'
import matplotlib.pyplot as plt
plt.rc('figure', figsize=(10, 6))
plt.style.use('ggplot')
import locale
locale.setlocale(locale.LC_ALL, 'en_GB')
import os
import time
import itertools
from astropy.coordinates import SkyCoord
from astropy.table import Table
from astropy import units as u
from astropy import visualization as vis
import numpy as np
from matplotlib_venn import venn3
from herschelhelp_internal.masterlist import (nb_compare_mags, nb_ccplots, nb_histograms, find_last_ml_suffix,
quick_checks)
OUT_DIR = os.environ.get('OUT_DIR', "./data")
SUFFIX = find_last_ml_suffix()
#SUFFIX = "20171016"
master_catalogue_filename = "master_catalogue_xfls_{}.fits".format(SUFFIX)
master_catalogue = Table.read("{}/{}".format(OUT_DIR, master_catalogue_filename))
print("Diagnostics done using: {}".format(master_catalogue_filename))
quick_checks(master_catalogue).show_in_notebook()
flag_obs = master_catalogue['flag_optnir_obs']
flag_det = master_catalogue['flag_optnir_det']
venn3(
[
np.sum(flag_obs == 4),
np.sum(flag_obs == 2),
np.sum(flag_obs == 6),
np.sum(flag_obs == 1),
np.sum(flag_obs == 5),
np.sum(flag_obs == 3),
np.sum(flag_obs == 7)
],
set_labels=( 'mid-IR', 'near-IR', 'Optical'),
subset_label_formatter=lambda x: "{}%".format(int(100*x/len(flag_obs)))
)
plt.title("Wavelength domain observations");
venn3(
[
np.sum(flag_det[flag_obs == 7] == 4),
np.sum(flag_det[flag_obs == 7] == 2),
np.sum(flag_det[flag_obs == 7] == 6),
np.sum(flag_det[flag_obs == 7] == 1),
np.sum(flag_det[flag_obs == 7] == 5),
np.sum(flag_det[flag_obs == 7] == 3),
np.sum(flag_det[flag_obs == 7] == 7)
],
set_labels=('mid-IR', 'near-IR', 'Optical'),
subset_label_formatter=lambda x: "{}%".format(int(100*x/np.sum(flag_det != 0)))
)
plt.title("Detection of the {} sources detected\n in any wavelength domains "
"(among {} sources)".format(
locale.format('%d', np.sum(flag_det != 0), grouping=True),
locale.format('%d', len(flag_det), grouping=True)));
The master list if composed of several catalogues containing magnitudes in similar filters on different instruments. We are comparing the magnitudes in these corresponding filters.
u_bands = ["WFC u"]
g_bands = ["WFC g", "BASS g", "GPC1 g"]
r_bands = ["WFC r", "BASS r", "GPC1 r", "KPNO r"]
i_bands = ["WFC i", "GPC1 i"]
z_bands = ["WFC z", "GPC1 z"]
y_bands = [ "BASS z", "GPC1 y"]
We compare the histograms of the total aperture magnitudes of similar bands.
for bands in [u_bands, g_bands, r_bands, i_bands, z_bands, y_bands]:
colnames = ["m_{}".format(band.replace(" ", "_").lower()) for band in bands]
nb_histograms(master_catalogue, colnames, bands)
We compare one to one each magnitude in similar bands.
for band_of_a_kind in [u_bands, g_bands, r_bands, i_bands, z_bands, y_bands]:
for band1, band2 in itertools.combinations(band_of_a_kind, 2):
basecol1, basecol2 = band1.replace(" ", "_").lower(), band2.replace(" ", "_").lower()
col1, col2 = "m_ap_{}".format(basecol1), "m_ap_{}".format(basecol2)
nb_compare_mags(master_catalogue[col1], master_catalogue[col2],
labels=("{} (aperture)".format(band1), "{} (aperture)".format(band2)))
col1, col2 = "m_{}".format(basecol1), "m_{}".format(basecol2)
nb_compare_mags(master_catalogue[col1], master_catalogue[col2],
labels=("{} (total)".format(band1), "{} (total)".format(band2)))
Cross-match the master list to SDSS and 2MASS to compare its magnitudes to SDSS and 2MASS ones.
master_catalogue_coords = SkyCoord(master_catalogue['ra'], master_catalogue['dec'])
The catalogue is cross-matched to SDSS-DR13 withing 0.2 arcsecond.
We compare the u, g, r, i, and z magnitudes to those from SDSS using fiberMag
for the aperture magnitude and petroMag
for the total magnitude.
sdss = Table.read("../../dmu0/dmu0_SDSS-DR13/data/SDSS-DR13_xFLS.fits")
sdss_coords = SkyCoord(sdss['ra'] * u.deg, sdss['dec'] * u.deg)
idx, d2d, _ = sdss_coords.match_to_catalog_sky(master_catalogue_coords)
mask = (d2d < 0.2 * u.arcsec)
sdss = sdss[mask]
ml_sdss_idx = idx[mask]
for band_of_a_kind in [u_bands, g_bands, r_bands, i_bands, z_bands]:
for band in band_of_a_kind:
sdss_mag_ap = sdss["fiberMag_{}".format(band[-1])]
master_cat_mag_ap = master_catalogue["m_ap_{}".format(band.replace(" ", "_").lower())][ml_sdss_idx]
nb_compare_mags(sdss_mag_ap, master_cat_mag_ap,
labels=("SDSS {} (fiberMag)".format(band[-1]), "{} (aperture)".format(band)))
sdss_mag_tot = sdss["petroMag_{}".format(band[-1])]
master_cat_mag_tot = master_catalogue["m_ap_{}".format(band.replace(" ", "_").lower())][ml_sdss_idx]
nb_compare_mags(sdss_mag_ap, master_cat_mag_ap,
labels=("SDSS {} (petroMag)".format(band[-1]), "{} (total)".format(band)))
The catalogue is cross-matched to 2MASS-PSC withing 0.2 arcsecond. We compare the UKIDSS total J and K magnitudes to those from 2MASS.
The 2MASS magnitudes are “Vega-like” and we have to convert them to AB magnitudes using the zero points provided on this page:
| Band | Fν - 0 mag (Jy) |
|---|---|
| J | 1594 |
| H | 1024 |
| Ks | 666.7 |
In addition, UKIDSS uses a K band whereas 2MASS uses a Ks (“short”) band, this page give a correction to convert the K band in a Ks band with the formula:
$$K_{s(2MASS)} = K_{UKIRT} + 0.003 + 0.004 * (J−K)_{UKIRT}$$# The AB zero point is 3631 Jy
j_2mass_to_ab = 2.5 * np.log10(3631/1595)
k_2mass_to_ab = 2.5 * np.log10(3631/666.7)
twomass = Table.read("../../dmu0/dmu0_2MASS-point-sources/data/2MASS-PSC_xFLS.fits")
twomass_coords = SkyCoord(twomass['raj2000'], twomass['dej2000'])
idx, d2d, _ = twomass_coords.match_to_catalog_sky(master_catalogue_coords)
mask = (d2d < 0.2 * u.arcsec)
twomass = twomass[mask]
ml_twomass_idx = idx[mask]
nb_compare_mags(twomass['jmag'] + j_2mass_to_ab, master_catalogue['m_wfcam_j'][ml_twomass_idx],
labels=("2MASS J", "UHS J (total)"))
The graph above originally revealed that UHS needed conversion to AB.
From here, we are only comparing sources with a signal to noise ratio above 3, i.e. roughly we a magnitude error below 0.3.
To make it easier, we are setting to NaN in the catalogue the magnitudes associated with an error above 0.3 so we can't use these magnitudes after the next cell.
for error_column in [_ for _ in master_catalogue.colnames if _.startswith('merr_')]:
column = error_column.replace("merr", "m")
keep_mask = np.isfinite(master_catalogue[error_column])
keep_mask[keep_mask] &= master_catalogue[keep_mask][error_column] <= 0.3
master_catalogue[column][~keep_mask] = np.nan
nb_ccplots(
master_catalogue['m_gpc1_r'],
master_catalogue['m_ap_gpc1_r'] - master_catalogue['m_gpc1_r'],
"r total magnitude (GPC1)", "r aperture mag - total mag (GPC1)",
master_catalogue["stellarity"],
invert_x=True
)
nb_ccplots(
master_catalogue['m_wfc_g'] - master_catalogue['m_wfc_i'],
master_catalogue['m_wfcam_j'] - master_catalogue['m_wfc_z'],
"g - i (WFC)", "J - z (UHS, WFC)",
master_catalogue["stellarity"]
)
nb_ccplots(
master_catalogue['m_wfc_i'] - master_catalogue['m_irac_i1'],
master_catalogue['m_wfc_g'] - master_catalogue['m_wfc_i'],
"WFC i - IRAC1", "g - i (WFC)",
master_catalogue["stellarity"]
)
nb_ccplots(
master_catalogue['m_gpc1_g'] - master_catalogue['m_gpc1_r'],
master_catalogue['m_gpc1_i'] - master_catalogue['m_gpc1_z'],
"g - r (GPC1)", "i - z (GPC1)",
master_catalogue["stellarity"]
)
nb_ccplots(
master_catalogue['m_wfcam_j'] - master_catalogue['m_irac_i1'],
master_catalogue['m_irac_i2'] - master_catalogue['m_wfc_g'],
"J - irac_i1 (UHS, IRAC)", "irac_i2 - g (IRAC, WFC)",
master_catalogue["stellarity"]
)
nb_ccplots(
master_catalogue['m_wfc_i'] - master_catalogue['m_wfc_z'],
master_catalogue['m_wfc_z'] - master_catalogue['m_wfcam_j'],
"i - z (WFC)", "z - J (WFC, UHS)",
master_catalogue["stellarity"]
)
nb_ccplots(
master_catalogue['m_irac_i3'] - master_catalogue['m_irac_i4'],
master_catalogue['m_irac_i1'] - master_catalogue['m_irac_i2'],
"IRAC3 - IRAC4", "IRAC1 - IRAC2",
master_catalogue["stellarity"]
)


[1]
Great Video Quality; Doesn't Work - The Tape Feeding Carriage Eats EVERY TAPE
[2]
good video quality; Mechanical failures, terrible service


Torstar to close StarMetro national free newspaper chain, lay off 73 employees
Torstar Corp. will shutter its StarMetro newspapers across the country and lay off 73 staff. A Torstar spokesperson says the StarMetro papers will publish their final editions on December 20.
by Canadian PressTorstar Corp. will shutter its StarMetro newspapers across the country and lay off 73 staff.
A Torstar spokesperson says the StarMetro papers will publish their final editions on December 20.
The company publishes the commuter papers in Vancouver, Edmonton, Calgary, Toronto and Halifax.
A memo sent to staff from Torstar president John Boynton says the closures will affect 73 people working in editorial, advertising and distribution.
The company also announced plans to open new Star bureaus in the coming weeks in Vancouver, Edmonton, Calgary and Halifax.
The bureaus will be staffed by Star journalists who will provide local coverage.
This report by The Canadian Press was first published on Nov. 19, 2019.
———
Torstar holds an investment in The Canadian Press as part of a joint agreement with subsidiaries of the Globe and Mail and Montreal's La Presse.
The Canadian Press


The goal of this document is to get you up and running with httr as quickly as possible. httr is designed to map closely to the underlying http protocol. I’ll try and explain the basics in this intro, but I’d also recommend “HTTP: The Protocol Every Web Developer Must Know” or “HTTP made really easy”.
This vignette (and parts of the httr API) derived from the excellent “Requests quickstart guide” by Kenneth Reitz. Requests is a python library similar in spirit to httr.
There are two important parts to http: the request, the data sent to the server, and the response, the data sent back from the server. In the first section, you’ll learn about the basics of constructing a request and accessing the response. In the second and third sections, you’ll dive into more details of each.
To make a request, first load httr, then call GET()
with a url:
This gives you a response object. Printing a response object gives you some useful information: the actual url used (after any redirects), the http status, the file (content) type, the size, and if it’s a text file, the first few lines of output.
r
#> Response [http://httpbin.org/get]
#> Date: 2018-12-06 20:11
#> Status: 200
#> Content-Type: application/json
#> Size: 325 B
#> {
#> "args": {},
#> "headers": {
#> "Accept": "application/json, text/xml, application/xml, */*",
#> "Accept-Encoding": "gzip, deflate",
#> "Connection": "close",
#> "Host": "httpbin.org",
#> "User-Agent": "libcurl/7.54.0 r-curl/3.2 httr/1.4.0"
#> },
#> "origin": "<IP_ADDRESS>",
#> ...
You can pull out important parts of the response with various helper methods, or dig directly into the object:
status_code(r)
#> [1] 200
headers(r)
#> $connection
#> [1] "keep-alive"
#>
#> $server
#> [1] "gunicorn/19.9.0"
#>
#> $date
#> [1] "Thu, 06 Dec 2018 20:11:46 GMT"
#>
#> $`content-type`
#> [1] "application/json"
#>
#> $`content-length`
#> [1] "325"
#>
#> $`access-control-allow-origin`
#> [1] "*"
#>
#> $`access-control-allow-credentials`
#> [1] "true"
#>
#> $via
#> [1] "1.1 vegur"
#>
#> attr(,"class")
#> [1] "insensitive" "list"
str(content(r))
#> List of 4
#> $ args : Named list()
#> $ headers:List of 5
#> ..$ Accept : chr "application/json, text/xml, application/xml, */*"
#> ..$ Accept-Encoding: chr "gzip, deflate"
#> ..$ Connection : chr "close"
#> ..$ Host : chr "httpbin.org"
#> ..$ User-Agent : chr "libcurl/7.54.0 r-curl/3.2 httr/1.4.0"
#> $ origin : chr "<IP_ADDRESS>"
#> $ url : chr "http://httpbin.org/get"
I’ll use httpbin.org
throughout this introduction. It accepts many types of http request and returns json that describes the data that it received. This makes it easy to see what httr is doing.
As well as GET()
, you can also use the HEAD()
, POST()
, PATCH()
, PUT()
and DELETE()
verbs. You’re probably most familiar with GET()
and POST()
: GET()
is used by your browser when requesting a page, and POST()
is (usually) used when submitting a form to a server. PUT()
, PATCH()
and DELETE()
are used most often by web APIs.
The data sent back from the server consists of three parts: the status line, the headers and the body. The most important part of the status line is the http status code: it tells you whether or not the request was successful. I’ll show you how to access that data, then how to access the body and headers.
The status code is a three digit number that summarises whether or not the request was successful (as defined by the server that you’re talking to). You can access the status code along with a descriptive message using http_status()
:
r <- GET("http://httpbin.org/get")
# Get an informative description:
http_status(r)
#> $category
#> [1] "Success"
#>
#> $reason
#> [1] "OK"
#>
#> $message
#> [1] "Success: (200) OK"
# Or just access the raw code:
r$status_code
#> [1] 200
A successful request always returns a status of 200. Common errors are 404 (file not found) and 403 (permission denied). If you’re talking to web APIs you might also see 500, which is a generic failure code (and thus not very helpful). If you’d like to learn more, the most memorable guides are the http status cats.
You can automatically throw a warning or raise an error if a request did not succeed:
I highly recommend using one of these functions whenever you’re using httr inside a function (i.e. not interactively) to make sure you find out about errors as soon as possible.
There are three ways to access the body of the request, all using content()
:
content(r, "text")
accesses the body as a character vector:
r <- GET("http://httpbin.org/get")
content(r, "text")
#> No encoding supplied: defaulting to UTF-8.
#> [1] "{\n \"args\": {}, \n \"headers\": {\n \"Accept\": \"application/json, text/xml, application/xml, */*\", \n \"Accept-Encoding\": \"gzip, deflate\", \n \"Connection\": \"close\", \n \"Host\": \"httpbin.org\", \n \"User-Agent\": \"libcurl/7.54.0 r-curl/3.2 httr/1.4.0\"\n }, \n \"origin\": \"<IP_ADDRESS>\", \n \"url\": \"http://httpbin.org/get\"\n}\n"
httr will automatically decode content from the server using the encoding supplied in the content-type
HTTP header. Unfortunately you can’t always trust what the server tells you, so you can override encoding if needed:
If you’re having problems figuring out what the correct encoding should be, try stringi::stri_enc_detect(content(r, "raw"))
.
For non-text requests, you can access the body of the request as a raw vector:
content(r, "raw")
#> [1] 7b 0a 20 20 22 61 72 67 73 22 3a 20 7b 7d 2c 20 0a 20 20 22 68 65 61
#> [24] 64 65 72 73 22 3a 20 7b 0a 20 20 20 20 22 41 63 63 65 70 74 22 3a 20
#> [47] 22 61 70 70 6c 69 63 61 74 69 6f 6e 2f 6a 73 6f 6e 2c 20 74 65 78 74
#> [70] 2f 78 6d 6c 2c 20 61 70 70 6c 69 63 61 74 69 6f 6e 2f 78 6d 6c 2c 20
#> [93] 2a 2f 2a 22 2c 20 0a 20 20 20 20 22 41 63 63 65 70 74 2d 45 6e 63 6f
#> [116] 64 69 6e 67 22 3a 20 22 67 7a 69 70 2c 20 64 65 66 6c 61 74 65 22 2c
#> [139] 20 0a 20 20 20 20 22 43 6f 6e 6e 65 63 74 69 6f 6e 22 3a 20 22 63 6c
#> [162] 6f 73 65 22 2c 20 0a 20 20 20 20 22 48 6f 73 74 22 3a 20 22 68 74 74
#> [185] 70 62 69 6e 2e 6f 72 67 22 2c 20 0a 20 20 20 20 22 55 73 65 72 2d 41
#> [208] 67 65 6e 74 22 3a 20 22 6c 69 62 63 75 72 6c 2f 37 2e 35 34 2e 30 20
#> [231] 72 2d 63 75 72 6c 2f 33 2e 32 20 68 74 74 72 2f 31 2e 34 2e 30 22 0a
#> [254] 20 20 7d 2c 20 0a 20 20 22 6f 72 69 67 69 6e 22 3a 20 22 37 36 2e 33
#> [277] 31 2e 32 30 35 2e 32 33 35 22 2c 20 0a 20 20 22 75 72 6c 22 3a 20 22
#> [300] 68 74 74 70 3a 2f 2f 68 74 74 70 62 69 6e 2e 6f 72 67 2f 67 65 74 22
#> [323] 0a 7d 0a
This is exactly the sequence of bytes that the web server sent, so this is the highest fidelity way of saving files to disk:
httr provides a number of default parsers for common file types:
# JSON automatically parsed into named list
str(content(r, "parsed"))
#> List of 4
#> $ args : Named list()
#> $ headers:List of 5
#> ..$ Accept : chr "application/json, text/xml, application/xml, */*"
#> ..$ Accept-Encoding: chr "gzip, deflate"
#> ..$ Connection : chr "close"
#> ..$ Host : chr "httpbin.org"
#> ..$ User-Agent : chr "libcurl/7.54.0 r-curl/3.2 httr/1.4.0"
#> $ origin : chr "<IP_ADDRESS>"
#> $ url : chr "http://httpbin.org/get"
See ?content
for a complete list.
These are convenient for interactive usage, but if you’re writing an API wrapper, it’s best to parse the text or raw content yourself and check it is as you expect. See the API wrappers vignette for more details.
Access response headers with headers()
:
headers(r)
#> $connection
#> [1] "keep-alive"
#>
#> $server
#> [1] "gunicorn/19.9.0"
#>
#> $date
#> [1] "Thu, 06 Dec 2018 20:11:46 GMT"
#>
#> $`content-type`
#> [1] "application/json"
#>
#> $`content-length`
#> [1] "325"
#>
#> $`access-control-allow-origin`
#> [1] "*"
#>
#> $`access-control-allow-credentials`
#> [1] "true"
#>
#> $via
#> [1] "1.1 vegur"
#>
#> attr(,"class")
#> [1] "insensitive" "list"
This is basically a named list, but because http headers are case insensitive, indexing this object ignores case:
Like the response, the request consists of three pieces: a status line, headers and a body. The status line defines the http method (GET, POST, DELETE, etc) and the url. You can send additional data to the server in the url (with the query string), in the headers (including cookies) and in the body of POST()
, PUT()
and PATCH()
requests.
A common way of sending simple key-value pairs to the server is the query string: e.g. http://httpbin.org/get?key=val
. httr allows you to provide these arguments as a named list with the query
argument. For example, if you wanted to pass key1=value1
and key2=value2
to http://httpbin.org/get
you could do:
r <- GET("http://httpbin.org/get",
query = list(key1 = "value1", key2 = "value2")
)
content(r)$args
#> $key1
#> [1] "value1"
#>
#> $key2
#> [1] "value2"
Any NULL
elements are automatically dropped from the list, and both keys and values are escaped automatically.
You can add custom headers to a request with add_headers()
:
r <- GET("http://httpbin.org/get", add_headers(Name = "Hadley"))
str(content(r)$headers)
#> List of 7
#> $ Accept : chr "application/json, text/xml, application/xml, */*"
#> $ Accept-Encoding: chr "gzip, deflate"
#> $ Connection : chr "close"
#> $ Cookie : chr "a=1; b=1"
#> $ Host : chr "httpbin.org"
#> $ Name : chr "Hadley"
#> $ User-Agent : chr "libcurl/7.54.0 r-curl/3.2 httr/1.4.0"
(Note that content(r)$header
retrieves the headers that httpbin received. headers(r)
gives the headers that it sent back in its response.)


Overlay Clock Options
24-Hour Clock
Full screen only
Text Color:
Background Color:
Background Opacity (0..1):
Font Size:
Font Family:
Margin from right side:
Margin from top:
Save


The following sets out the terms and condition for use of the Partiko website, application and our services.
1.1 These are the terms of use, including the terms and conditions of supply (Terms), for www.Partiko.com and the Partiko application. For the purposes of these Terms, both the website and application shall be referred to as the "App". The App is operated by Partiko Services Private Ltd trading as Partiko (we, us and our). We are a Private limited company, registered in New Delhi, India.
1.2 Your use of the App and your Purchase of any of the Bookings/Tickets offered via our App is subject to these Terms and by placing an order for any Bookings/Tickets you agree to be bound by them. You should print a copy of these Terms for future reference. Use of your personal information submitted via this App is governed by our privacy policy.
1.3 We reserve the right to change these Terms from time to time by changing them on the App, although no such change will affect any Purchase you have already made with us. Your continued use of the App and any new Purchases will be bound by the new Terms. These Terms were last updated on June 30, 2015.
1.4 As a consumer, nothing in these Terms will prevent you or stop you from being able to enforce or receive the full benefit of your legal rights provided under general law.
1.5 In these Terms we use various capitalised terms (they are "defined"). This means they have special meanings, found in the next-to-last section of these Terms.
2.1 To use the App and make any Purchases, you must be 18 or over. By continuing to use the App and agreeing to these Terms you are representing to us that you are 18 and we can rely on this representation.
2.2 The App and the Events offered on the App are only directed at people who access the App and make Purchases. We do not represent that any Events are suitable outside Delhi NCR and you should be careful to satisfy yourself of a Event's suitability to your circumstances (such as considering your travel arrangements to/from the event because unless this is expressly stated as part of the Event, it is not included as part of the Purchase). If you choose to use the App or make a Purchase outside the Delhi NCR you do so at your own initiative.
2.3 We grant you a limited licence to use the App to access and use our services for your own personal and non-commercial use, provided that you comply fully with these Terms (e.g. you must not re-sell the Tickets).
2.4 We reserve the right to prevent you using the App or making Purchases, however we will honour Purchases already made, unless you have not complied with these Terms or we are unable to because of circumstances outside our control. For more on this, please read below.
3.1 We cannot guarantee the continuous, uninterrupted or error-free operability of the App. There may be times when certain features, parts or content of the App, or the entire App, become unavailable (whether on a scheduled or unscheduled basis) or are modified, suspended or withdrawn by us, in our sole discretion, without notice to you. You agree that we will not be liable to you or to any third party for any unavailability, modification, suspension or withdrawal of the App, or any features, parts or content of the App.
3.2 We may change the format and content of the App from time to time. We reserve the right to modify, change, substitute or withdraw any Events or other information on our App. You agree that your use of the App is on an 'as is' and 'as available' basis and at your sole risk.
4.1 Why register? To put simply, if you don't register an account, you won't be able to make any Purchases. This is because you need an account in order to view your Bookings/Tickets, redeem them (if required), view your past Purchases, store your financial details and modify your preferences to name a few. We reserve the right to decline a new registration or cancel your account at any time (including if you don't provide us with a valid e-mail address that is personal to you, or if you don't provide us with a correct name and surname).
4.2 To register an account you will need to fill out a form on the mobile app or online.  You will promptly inform us of any changes to such information (you can do this by updated your account details at any time). The personal information you give us is governed by our privacy policy.
4.3 In order to register and access your account, you will need to choose a password. It is important you keep this password confidential because you are entirely responsible if you do not maintain the confidentiality of your password to a reasonably expected standard and Purchases are made via your account. Let us know as soon as you become aware there has been a breach of security and we will suspend your account. You agree that any person who you directly or implicitly permit to use your password (implicitly, for example, because you do not log out of your account and another person uses your device to make Purchases or you write your password on a noticeboard in your home and a family member then uses it to gain access to your account) is authorized to act as your agent to use the App and make Purchases via your account. You will not be responsible to pay for Purchases made after you have notified us of a password change or that security has been compromised.
4.4 One individual user is allowed to register only one account on the App. You warrant that you will not create fraudulent accounts. You also warrant that you will not use any fraudulent activities to generate unfair Reward Credits in the App to be applied to you (for instance, you will not redeem your own invitation code with a different account of yours).
5.1 You may only use the App for non-commercial use and only in accordance with these Terms. You may retrieve and display content from the App on a computer or mobile device screen, print and copy individual pages and Bookings/Tickets and, subject to the next section, store such pages and/or Tickets in electronic form. Additional terms may also apply to certain features, parts or content of the App and, where they apply, they will be displayed before you access the relevant features, parts or content.
6.1 Except to the extent expressly set out in these Terms, you are not allowed to:
6.2 You must only use the App and anything available from the App for lawful purposes (complying with all applicable laws and regulations), in a responsible manner, and not in a way that might damage our name or reputation or that of any of our affiliates.
6.3 All rights granted to you under these Terms will terminate immediately in the event that you have not followed your responsibilities as required by them (legally known as a "breach").
7.1 All intellectual property rights (which includes rights such as copyright, and rights in trade marks) in any content of the App (including text, graphics, software, photographs and other images, videos, sound, trade marks and logos) are owned by us and/or our licensors. Except as expressly set out in these Terms, nothing in these Terms gives you any rights in respect of any intellectual property owned by us or our licensors and you acknowledge that you do not acquire any ownership rights by downloading content from the App. If you print off, copy or store pages from the App (only as permitted by these terms and conditions), you must ensure that any copyright, trade mark or other intellectual property right notices contained in the original content are reproduced.
7.2 You agree that by submitting any posting, images or other content for publication on the App (Your Content), you retain any copyright you may have in Your Content, however you grant us and our affiliates a perpetual, irrevocable, worldwide, non-exclusive, royalty-free and fully sub-licensable right and licence to use, reproduce, edit, modify, adapt, publish, translate, create derivative works from, distribute, perform and display such content (in whole or in part) and/or to incorporate it into other works in any form, media or technology, whether for commercial or non-commercial purposes. You waive any moral rights you may have in, or to be identified as the author, of Your Content.
7.3 You are solely responsible for Your Content (including content you share with other sites, such as social networking sites) and we do not endorse Your Content or any opinion, recommendation, or advice expressed therein, and we expressly disclaim any and all liability in connection with Your Content.
8.1 The App may, from time to time, make message boards, news groups and/or other public forums (collectively Review Forums) available to you so that you can feedback on Events offered on the App and read the feedback submitted by other users of the App. We do not control the material submitted to Review Forums (collectively Postings), nor are Review Forums moderated. You are solely responsible for the content of your Postings as submitted by you and acknowledge that all Postings express the views of their respective authors, and not our views.
If you participate in any Review Forum, you must:
You agree that, by submitting any Posting, you grant us and our affiliates a perpetual, irrevocable, worldwide, non-exclusive, royalty-free and fully sub-licensable right and licence to use, reproduce, modify, adapt, publish, translate, create derivative works from, distribute, perform and display such Posting (in whole or part) and/or to incorporate it in other works in any form, media or technology, and you waive any moral rights you may have in, or to be identified as the author, of such Posting.
Whilst we do not screen or monitor Postings, we reserve the right, in our sole discretion, to delete, edit or modify any Posting submitted by you and/or to close any topic, at any time without notice to you.
Complaints about the content of any Posting must be sent to<EMAIL_ADDRESS>and must contain details of the specific Posting giving rise to the complaint
9.1 The App may, from time to time, include links to external sites. We have included links to these sites to provide you with access to information and services that you may find useful or interesting. We are not responsible for the content of these sites or for anything provided by them and do not guarantee that they will be continuously available. The fact that we include links to such external sites does not imply any endorsement of our association with their operators.
Use of your personal information submitted via the App is governed by our privacy policy.
11.1 Your relationship with the Merchant
Except for a very small number of Events, we act as a disclosed agent for our Merchants, such as a theatre or concert promoter. This means that the contract for the Event is between you and the Merchant. In most cases this means there are likely to be additional terms and conditions which apply to your contract with the Merchant (because each Merchant has different terms relevant to the Event, for example a concert promoter will have different terms of entry than a theatre). These additional terms, if any, shall be made known to you at the time of Purchase, and/or you may Contact Us for details. We will also provide a link to the terms in the ticket confirmation email and/or as part of the redemption instructions we send you. You shall ensure that anyone using a Booking/Ticket with a Merchant complies with those terms.
11.2 Where we act as agent this means that we have no contractual liability to you in respect of that particular Event. However, we may still be liable to you if we have been negligent, made a fraudulent misrepresentation or been in breach of any other relevant law. For a small number of Events we may act as principal rather than agent, which means the contract for the Event is between you and us. We will let you know where we act as principal, otherwise we will always be acting as agent.
11.3 It is important to note that it is the Merchant, not us, who is the seller of the Events. Therefore, if you have a complaint with the quality of the Events your complaint lies with the Merchant, not Partiko Services Private Limited, although we'd still love to hear your feedback so we can decide whether or not to continue offering events from that Merchant in the future. Contact details for the Merchant will be provided in the confirmatory email and/or in the redemption instructions we send you when you make a Purchase. We will of course use our reasonable endeavors to assist you with providing feedback to the Merchant if you so request: Contact us.
11.4 Since your contract is not with us, but with a Merchant, we may pass essential booking details to that Merchant (remember, they are not a part of our company, but are third parties to whom we act as agent for). The placing of an order to purchase a Booking/Ticket will constitute consent to us passing your details for this.
11.5 Bookings/Tickets
For most events you will receive an electronic Booking/Ticket or redemption instructions, since Partiko generally works on the basis of selling last-minute Event tickets (e.g. Nightlife Entries). Sometimes you will need to collect your Bookings/Tickets from the collection point where we are unable to send the electronic Booking/Ticket straight to your account. You will be notified if this is necessary and be provided with collection details, including location and times. You must take the acknowledgment of your order with you and the credit/debit card you used to make the order. If you fail to arrive at the collection point within the time specified, you will forfeit your ticket and we will not provide a refund.
11.6 Tickets must be used by the date of the Event shown on the Booking/Ticket, or it will no longer be valid (and you will not be entitled to a refund).
11.7 Tickets may be restricted to a maximum number. You will be informed of this at the point of purchase.
11.8 It is your responsibility to check your Tickets as if you have made a mistake it cannot always be rectified after purchase. Please check your Ticket(s) on receipt carefully and Contact Us immediately prior to the Event if there is a mistake, or if you have not received your Ticket(s).
11.9 It is your responsibility to ascertain whether an Event has been cancelled or re-scheduled and the date and time of the re-scheduled Event. We will use reasonable endeavours to notify you of a cancelled or re-scheduled Event but we do not guarantee you will be informed of such cancellation before the time for the Event.
11.10 Process of purchasing
Tickets may be Purchased by clicking on the Events you wish to Purchase and then following the prompts that will appear on-screen. You may check and correct any input errors in your order up until the point at which you submit your order to us by clicking the "Confirm Booking" button within the App.
11.11 Where a concession is claimed, proof of identity and concession entitlement (for example of age or student status) may be required.
11.12 Once submitted, your order constitutes an offer to us to Purchase a Ticket. All orders are subject to acceptance by us. We are not obliged to accept your order and may, in our discretion, decline to accept any order. Where we accept your order, we will confirm such acceptance to you by sending you an email that confirms that we have accepted your order and providing details of your Ticket. Notwithstanding our acceptance, we may immediately terminate or suspend the Purchase (and suspend or void the Ticket) if subsequently your payment details are found to be invalid or lack funds by our payment provider, or we or our payment provider reasonably suspect fraudulent behaviour linked with your account.
11.13 Reproduction, sale, resale or trade of a Ticket is prohibited. If you attempt to do this we reserve the right to void the Ticket and cancel your account. However, we encourage you to Purchase Tickets and give them as gifts!
11.14 Additional terms
Your Booking/ticket remains the property of the Merchant and is a personal revocable licence which may be withdrawn and admission refused at any time upon refunding the printed purchase price.
11.15 Our Merchants may prohibit us from issuing exchanges or refunds after a Purchase is made, or for lost, stolen, damaged or destroyed tickets. It is your responsibility to keep your tickets safe, whether in digital or paper ticket formats. It is not always possible to issue duplicate tickets. If duplicates are being issued, a reasonable administration charge may be levied.
11.16 We may limit the amount of Bookings/Tickets you can buy to an Event. We reserve the right, on reasonable suspicion, to cancel without notice or liability to you any order for Tickets purchased over any specified limits or if we reasonably suspect fraudulent conduct in connection with the Purchase.
11.17 A ticket shall not be used for advertising, promotions, contests or sweepstakes without the Merchant's and Partiko Services Private Limited written consent.
Tickets are sold subject to the Event Partner's right to alter or vary the programme due to events or circumstances beyond its reasonable control without being obliged to refund monies or exchange Tickets other than in certain cases set out in Our refunds policy .
11.19 The venue may refuse or revoke admission should you or your guests breach any terms and conditions of the Event or Merchant, or otherwise upon reasonable grounds. Every effort to admit latecomers will be made at a suitable break in the event, but admission cannot be guaranteed. Ticket-holders may only leave and re-enter a venue during an Event at the discretion of the management of the venue. You only have the right to a seat corresponding to that stated on the Ticket, but the Merchant reserves the right to provide alternative seats to those stated on the Ticket.
12.1 The price of Tickets is as quoted on the App from time to time. Prices include VAT, if applicable.
Prices are liable to change at any time, but changes will not affect Purchases in respect of which we have already sent you an email confirmation.
12.2 Payment for all orders must be made by credit or debit card by entering such information in the Settings part in the App or as part of the booking process.
12.3 You should be aware that online payment transactions are subject to validation checks by your card issuer and we are not responsible if your card issuer declines to authorise payment for any reason. Please note, it is possible that your card issuer may charge you an online handling fee or processing fee. We are not responsible for this.
Partiko Services Private Limited reserves the right to terminate the reward credits scheme or to change these terms and conditions, regulations, or benefits of participation, in whole or in part, at any time with or without notice, even though changes may affect the number of reward credits accumulated by the user.
13.2 Reward Credits that are not redeemed will expire three months from the date they are awarded.
13.3 If Partiko Services Private Limited believes, in its sole discretion, that a user is abusing the reward credits (e.g. sharing on deal and voucher websites), it will revoke all reward credits awarded to that user.
13.4 If reward credits are redeemed, and the user fails to attend the event, Partiko Services Private Limited will not refund the redeemed reward credits.
13.5 Rewards credits earned from two or more different user's accounts cannot be combined and redeemed on the same booking.
13.6 Reward credits cannot be exchanged for cash and cannot be used anywhere other than on the Partiko app.
13.7 Reward credits cannot be purchased.
13.8 When converting reward credit amounts between currencies, Partikos Ltd. reserves the right to determine the exchange rate to be used.
14.1 Purchases for Tickets cannot be exchanged or refunded, except in the following circumstances:
(a) If we discover an error in the price of the Tickets you have ordered, we will use reasonable endeavors to inform you as soon as possible and allow you to either reconfirm your order at the correct price (crediting or debiting your account as applicable), or cancel your order. If you choose to cancel, you will receive a full refund from us if you've already paid. If we are unable to contact you, this will be treated as a cancellation.
(b) If an Event is cancelled or there is a material change to the subject matter of the Ticket contract (that is what you have contracted to see) we will give you a full refund of the face value price paid or, if the face value has been reduced by the Event Partner, the discounted face value. A material change is one which, in our reasonable opinion, makes the Event materially different to what a purchaser of the Event, taken generally, could reasonably expect. For example, the use of understudies in a theatre performance does not constitute a material change. If an event is re-scheduled (and you cannot attend the re-scheduled date), we will coordinate with the Event Partner on how your ticket(s) will be treated however a refund cannot be guaranteed.
14.2 Paying refunds
We will usually refund any money received from you using the same method originally used by you to pay for your purchase.
You may reject a credit or refund within 30 days of receiving the credit or refund, but if you do not reject the credit or refund by notifying us within that timeframe you will be deemed to have accepted the credit or refund in full and final settlement of any and all claims, actions, demands and proceedings you may have against Partiko Services Private Limited arising out of the Ticket or Purchase for which you received the credit or refund.
14.3 Your legal rightsNothing in these Terms limits or takes away from your legal rights under general law, however please note that there is an exemption to the cancellation rights in respect of contracts for leisure service activities on specific dates under the Consumer Contracts (Information, Cancellation and Additional Charges) Regulations. As such, Purchases made via the App are generally non-cancellable and non-refundable, although you may be entitled to a refund in certain circumstances (see Our Refunds Policy). For more information, please contact your local Citizens Advice Bureau, phone numbers can be found on their national website at www.nacab.org.Delhi NCR.
We warrant that we will exercise reasonable care and skill in performing our obligations under these Terms. Provided we have done so, we shall not be liable for errors or omissions, although we do, however, issue credits and refunds in limited circumstances (see section Our Refunds Policy). In the event of an error or omission we will use reasonable endeavours to correct any errors or omissions as soon as reasonably practicable after we become aware.
Except as expressly stated in these Terms, all warranties, conditions or other terms, whether express or implied by statute or common law or otherwise are excluded to the fullest extent permitted by law. This does not stop you from exercising your legal rights under general law to the extent that we cannot lawfully exclude them, or claiming any remedies you might be entitled to under general law.
16.1 Nothing in these Terms shall limit or exclude our liability to you.
16.2 Subject to this, in no event shall we be liable to you for any business losses (and loss of profits shall always be treated as a type of business loss) and any liability we do have for losses you suffer arising from any Purchases shall not exceed 100% of the aggregate amount spent on the Purchase for the relevant Ticket(s). Further, our liability to you for any and all losses however they arise in connection with these Terms and your use of the App (including any Purchases) is strictly limited to losses that were reasonably foreseeable. Losses are foreseeable where they could be contemplated by you and us at the time your order is accepted by us.
16.3 Other than as expressly described in these Terms, Partiko does not warrant and excludes all liability in respect of, or to provide, the Events for which Tickets may be redeemed, including in respect of the quality, safety, usability or any other aspect of the Events in respect of which a Ticket is or may be redeemed. We do, however, issue credits and refunds in limited circumstances (see section Our Refunds Policy).
16.4 We will not be liable or responsible for any failure to perform, or delay in performance of, any of our obligations that are caused by events outside our reasonable control.
16.5 Where videos are displayed they are intended to be purely representative of the artist or event. Your actual experience may vary.
17.1 We may suspend or terminate all or part of your use of the App, your account and/or a Purchased Ticket if you use (or permit anyone other than you to use) the App, your account or a Purchased Ticket in breach of these Terms and we do not reasonably consider that your breach can be resolved, or if it can be resolved you have failed to resolve it to our reasonable satisfaction after we have asked you to do so and given you a reasonable opportunity to do so.
17.2 Termination shall not prejudice any other right or remedy you or we may have in respect of accrued rights (including rights in respect of any breach) or liabilities which arose prior to termination.
18.1 These Terms are personal to you. You may not transfer or assign any or all of your rights or obligations under these Terms to any other person without our consent.
18.2 All notices given by you to us must be given in writing to the address set out at the end of these Terms. We may give notice to you at either the email or postal address you provide to us when placing an order.
18.3 If we fail to enforce any of our rights, it does not result in a waiver of that right.
18.4 If any provision of these Terms is found to be unenforceable, that provision shall be struck out and where capable all other provisions shall remain in force unaffected.
18.5 These Terms may not be varied except with our express written consent.
18.6 These Terms and any document expressly referred to in them constitute the entire agreement between you and us about the subject matter of these Terms and, in relation to such subject matter, supersedes and extinguishes all earlier understandings and agreements between you and us and all earlier representations by us, including any innocent or negligent misrepresentations. We do not limit our liability to you for any fraudulent misrepresentations made by us in these Terms or otherwise.
18.7 All provisions of these Terms apply equally to and are for the benefit of partiko.
18.8 These Terms (and all non-contractual relationships between you and us) shall be governed by English law, and you agree that any dispute between you and us regarding them or any Purchase will only be dealt with by the nearest courts in England and Wales (nearest to where you reside).
19.1 In the first instance we request that you Contact Us if you have a complaint against us and we shall try to resolve it.
19.2 We shall deal with complaints by following the dispute resolution processes.
19.3 Nothing limits your right to bring a complaint against us by applying to your nearest court
"Merchant" means a third party partner of Partiko who sells the events and services for which a Purchase can be made.
"Purchase" or "Purchased" means the purchase of a Ticket.
"Ticket" means a ticket for a particular Event from a Merchant, which is subject to any additional terms of entry set by the Merchant.
"Events" means the events and/or services offered by a particular Merchant for which a Purchase can be made.
Please submit any questions you have about these Terms, an order you have placed or purchasing in general by email to<EMAIL_ADDRESS>or write to us at:
Partiko