Drone CI: Continous integration in custom docker environments
Having gotten accustomed to Docker, configuring the appropriate build environment for a Continuous Integration system like Travis CI or Shippable CI starts to feel incredibly tedious and archaic (particularly if you work primarily in a language like R or haskell that usually isn’t supported out of the box).
- We do not have to hack together a custom image environment
- We can build and test our environment locally instead of having to rely on trial-and-error pushes to the CI server
- We do not have to download, compile and install the development environment each time, (which frequently takes longer than the CI checks themselves and can break)
(Shippable provides a persistent environment too, by preserving the state of your ‘minion’. But unlike Shippable, I believe the Drone approach is unlikely that you can create troublesome side-effects in your environment, such as removing a necessary dependency from the shippable.yml
and yet not catching it since the dependency is still available on the minion from before. In the Drone approach, we start on the same docker image each time, but merely avoid the few minutes it might take to download that image).
Unfortunately, custom images are not available on the fully hosted drone.io system. (Though perhaps they’d accept pull requests that would add an R environment to their image library). Fortunately, the Drone team kindly provides an open source version of their platform that can be hosted on a self-hosted / private server (such as the new web darling DigitalOcean or Amazon’s EC2). This has other advantages as well – such as using privately hosted repositories (it also integrates with BitBucket and GitLab) or running very long tests / simulations (since we’re now paying for the server time ourselves, after all).
The easy way: use docker
We can deploy the Drone CI server somewhat more seamlessly by running it in a container itself. Rather than worry about the above configuration, we can simply launch an existing docker image for Drone, rather cleverly created by Matt Gruter:
docker run --name='drone' -d -p 8080:80 --privileged mattgruter/drone
- Now we can follow the setup instructions. Be sure to use the matching case in the application name (
Drone
notdrone
) and the appropriate URLs for the authorization call back.
Note that we must use a different port than 80, and that we must give this port explicitly in the Authorization callback URL: https://localhost:8080/auth/login/github
in order to authenticate.
Also note that in this approach, the Drone CI’s docker image library will be separate from the docker image library. To manage or update the images available, we have to first nsenter
into the Drone CI container.
This runs rather nicely on a tiny DigitalOcean droplet. Bare in mind that the tiny droplet has only 20 GB of disk space though, which can be consumed rather quickly with too many images. If many of the images use the same base templates, the total disk space required will fortunately be much lower than the sum of their virtual sizes.
experimenting with saving images
Being a docker image, we can snapshot and export it for later use, and meanwhile can even destroy our server instance.
docker export drone > dronedroplet.tar
Not clear that this works. Consider saving an image instead? Save container named drone as image named drone:droplet
docker commit drone drone:droplet
docker save drone:droplet > dronedroplet.tar
are these identical?
Hmm, doesn’t seem to store configuration, login is no longer valid. Starting a stopped container maintains the configuration of course, but not launching from scratch (e.g. the sqlite database is local to the container, not accessible through an externally linked volume).
Note that this tarball does not include the Drone CI image library itself, which is not part of the container but rather connected as a volume. This makes it quite a bit smaller, and that library can presumably be reconstructed from the docker hub.
Configuring Drone CI: the hard way
- Install and launch drone: (see drone/README)
- Add
DOCKER_OPTS="-H <IP_ADDRESS>:4243 -d"
to/etc/default/docker
- Kill the docker deamon and restart docker. Or run docker with the explicit binding:
sudo docker -d -H <IP_ADDRESS>:4243 &
- You may need to configure firewall, if ufw is running.
- References: drone/issues/149, drone/issues/24
- Now we can follow the setup instructions. Be sure to use the matching case in the application name (
Drone
notdrone
) and the appropriate URLs for the authorization call back.
Configuring an already-running docker session
Launch a named repository in deamon mode:
docker run -d -p 8787:8787 --name='drone' mattgruter/drone
Use a docker-based install to add nsenter
into your executable path:
docker run -v /usr/local/bin:/target jpetazzo/nsenter
Run nsenter
to log into the docker image:
nsenter -m -u -n -i -p -t `docker inspect --format '{{ .State.Pid }}' drone` /bin/bash
Now we can update or delete images with docker pull
, docker rmi
, etc.
This is useful with many containers, for instance, with our ssh container or rstudio container we may want to modify usernames and passwords, etc:
useradd -m $USER && echo "$USER:$PASSWORD" | chpasswd
Making this easier:
Add to .bashrc
:
function dock { sudo nsenter -m -u -n -i -p -t `docker inspect --format "$1"` /bin/bash; }
This defines the function dock
such that dock <name>
will enter a running container named <name>
. Note that we have to have nsenter
bound to the executable path as indicated above. Yay less typing.


On this page:
WebDAV (Web-based Distributed Authoring and Versioning) allows you to upload and download large files, multiple files, or folders of files to your course or project site more easily.
You can use WebDAV to upload and access files in your site's Resources or Drop Box, if you have the required permissions.
Consider the following:
Note: Filenames that include certain characters cannot be accepted. For a list of unsupported characters, see Unsupported characters.
To use WebDAV to upload and access files in Mac OS X 10.4 (Tiger) and later:
Command-k
. (Alternatively, from the Go
menu, choose Connect to Server
.)
Contact your site administrator for the URL's format; it will likely include the siteID for your site. For instructions on finding your siteID, see Determining your site's siteID.
You may now drag and drop folders between your computer and the sites to which you just connected.
Optionally, you may click the
+
(plus sign) to the right of the server address after you
enter it, and the server will be added to your list of favorite
servers.
When you log in, you can choose to have the passphrase remembered in your Keychain. If you do this, you will not be prompted for a passphrase when you log into your personal Resources or Drop Box or the Resources for any site to which you have access. Do not do this unless your computer is secured from use by others.
Note: When you use WebDAV to access resources using
this method, you may notice that .DS_store
files are
being created. Apple's knowledge base provides instructions for eliminating this
behavior.
Using WebDAV to upload and access files in Mac OS X 10.3 (Panther) and earlier requires a third-party client called Goliath.
Note: Goliath has some known performance issues, and may not work all of the time. Because of this, only limited support is available if you experience problems.
You can download a free copy of Goliath. Once you have downloaded the file:
.dmg
file. (Depending on your version and
configuration of StuffIt, the disk image may
automatically mount.)
Goliath 1.0.1
should now be
available. Drag and drop the Goliath folder contained within the disk
image to your hard disk.
Contact your site administrator for the URL's format; it will likely include the siteID for your site.
Note: For instructions on finding your siteID, see Determining your site's siteID.
Advanced settings
tab, and check Disable
Encoding of Macintosh Recourse
. Then click OK
.
The first time you attempt to connect, you may be prompted to
accept a certificate for the site. Click OK
if prompted.
You may now drag and drop folders between your computer and the sites to which you just connected.


Dear {Firstname}
Because you are a loyal customer we have determined that you are eligible to receive a AADA £ 500 Gift Card reward.
*Your will be presented with several exclusive reward offers
We ask you to take part in our quick and short survey to receive your ASDA £ 500 Gift Card.
We will use the resulting information to better serve all of our customers.
© ASDA


Sign up as Spintable's partner now! We will contact you within the next 48 hours.
We will review your information and contact you within the next 48 hours.


While Electronic Medical Record systems (EMRs) have dramatically improved provider access to patient information, much of this information is unstructured free text and not natively supported in the EMR.
As part of my Master's thesis I developed a biomedical named entity extraction system to make this free text more usefull. This system was implemented in the widely deployed open source medical informatics platform OpenMRS.
The module includes online processing of free-text clinical notes, interactive text renderings to drill down into results, and a standalone language model training application for continuous improvement of entity recognition performance.
The module, source, and documentation is available here.
This work was presented at the IEEE international Conference on Bioinformatics and Biomedicine 2015 in Washington, DC, PDF.
Biochemical processes are dynamic processes expressed over time (and space). Identifying the progression-order of an unsynchronized set of biological samples is crucial for comprehending the dynamics of the underlying molecular interactions.
Many existing methods based on minimum spanning trees do not directly capture internal structures such as clusters during the reconstruction. We developed the notion of the Cluster Spanning Tree that outperforms previous methods on many datasets.
This work was presented at the 12th International Symposium on Bioinformatics Research and Applications (ISBRA) in Minsk, Belarus. PDF
Schistosomiasis is a condition effecting rural and impoverished communites around the world. We are developing QDREC 2.0 the Quantal Dose Response Calculator and Quantitative Phenotype Analysis Workbench to allow for objective, quantitative, and reproducible analysis of image and video based drug screens.
QDREC 2.0 is a browser based web application that provides an interface to supervised and unsupervised machine learning algorithms and data visualizations that promote data exploration and consistant results across assays.
QDREC 2.0 is under development and yet to be published.Twitter offers novel insight into user sentiment through access to the live and spontaneous observations and reactions. This information is invaluable to policy makers and other civic entities.
To exploit this data, we developed machine learned Twitter sentiment models to examine location specific sentiment trends. We successfully correlated positive local sentiment with high civic activity through 311 reports.
We also developed the web application Atmospheres that monitors the live feed of Tweets from San Francisco to compute neighborhood sentiment trends.
I'm Ryan, a data scientist and engineer based in the Bay Area. I like finding solutions to data problems.
Sometimes I also like to play guitar and ride my motorcycle.
Social Media Pharmacovigilance
Adverse drug side effects are a leading cause of death during patient care. However, only an estimated 10% of drug side effects are identified during clinical trials.
The massive scale of social media makes it a promising data mining target for identifying uknown side effects.
We developed methods based on text processing, graph theory, and data integration to identify instances of these adverse drug reactions in Twitter.
This work was presented at the 2016 Midsouth Computational Biology Society anual conference.The journal article version of this work is currently under peer review for publication.


public class Quaternion
extends java.lang.Object
implements java.io.Serializable
| Modifier and Type | Field and Description |
|---|---|
static double |
EPSILON |
static java.lang.String |
INVALID_INTERPOLATION_PARAM |
static java.lang.String |
UNDEFINED_LOG_ZERO_QUATERNION_MSG |
static java.lang.String |
VECTOR_INVALID_LENGTH_MSG |
| Constructor and Description |
|---|
Quaternion()
Default Constructor.
|
Quaternion(double x,
double y,
double z,
double w)
Constructs and initializes a Quaternion with 4 input parameters
|
Quaternion(Quaternion another)
Copy constructor
|
| Modifier and Type | Method and Description |
|---|---|
Quaternion |
add(Quaternion another)
Performs addition of two quaternions
|
void |
addEq(Quaternion another)
Performs addition of two quaternions and assigns the result to this object
|
Quaternion |
conjugate()
Gets the conjugate of this quaternion
|
void |
conjugateEq()
Gets the conjugate of this quaternion and assigns it to this object
|
Quaternion |
divide(Quaternion another)
Performs division of this quaternion with the input quaternion, that is
this / another |
void |
divideEq(Quaternion another)
Performs division of this quaternion with the input quaternion, that is
this / another . |
boolean |
equals(java.lang.Object another) |
boolean |
equals(Quaternion another,
double threshold)
Checks if this Quaternion equals to the input Quaternion within the
specified tolerance threshold
|
Quaternion |
exp()
Gets the exponential of this Quaternion
|
static Quaternion |
fromAxisAngle(double[] axis,
double angleInDeg)
Gets the unit Quaternion of a rotation which is given by the input axis,
and angle (in degrees)
|
static Quaternion |
fromAxisAngleRad(double[] axis,
double angleInRad)
Gets the unit Quaternion of a rotation which is given by the input axis,
and angle (in radians)
|
static Quaternion |
fromEulerAngles(double roll,
double pitch,
double yaw)
Gets the unit Quaternion of a rotation specified by Euler .
|
double |
getAngle()
Gets the angle (in degree) in the angle-axis representation of the rotation
that this Quaternion represents
|
double |
getAngleRad()
Gets the angle (in radian) in the angle-axis representation of the rotation
that this Quaternion represents
|
static Quaternion |
getIdentity()
Gets an identity Quaternion (0.0, 0.0, 0.0, 1.0)
|
double[] |
getRotationAxis()
Gets the vector axis in the angle-axis representation of the rotation that
this Quaternion represents
|
double[][] |
getRotationMatrix()
Returns the rotation matrix represented by the normalized version of
this quaternion
|
double |
getScalarPart()
Get scalar component (w-component) of this quaternion
|
double[] |
getVectorPart()
Gets the vector component (x, y, z) of this quaternion
|
double |
getW()
Gets w-component (scalar component) of this quaternion
|
double |
getX()
Gets x-coordinate of this quaternion
|
double |
getY()
Gets y-coordinate of this quaternion
|
double |
getZ()
Gets z-coordinate of this quaternion
|
int |
hashCode() |
Quaternion |
inverse()
Gets the inverse (reciprocal) of this quaternion
|
void |
inverseEq()
Inverts this quaternion
|
void |
invert()
Inverts this quaternion
|
boolean |
isIdentity()
Checks if this Quaternion is an identity quaternion (0.0, 0.0, 0.0, 1.0)
|
boolean |
isUnit()
Checks if this Quaternion is a unit quaternion
|
static Quaternion |
lerp(Quaternion from,
Quaternion to,
double t)
Interpolates linearly between
from and to Quaternion. |
Quaternion |
log()
Gets the natural logarithm of this Quaternion
|
Quaternion |
multiply(double scalar)
Performs scalar multiplication of this quaternion and the input number
|
Quaternion |
multiply(Quaternion another)
Performs multiplication of this quaternion with the input quaternion,
that is
this * another |
void |
multiplyEq(double scalar)
Performs scalar multiplication of this quaternion and the input number.
|
void |
multiplyEq(Quaternion another)
Performs multiplication of this quaternion with the input quaternion,
that is
this * another . |
double |
norm()
Computes the norm of this quaternion
|
void |
normalize()
Normalizes the quaternion so that it has norm 1
|
double[] |
rotate(double[] vector)
Rotates a 3D vector by the rotation represented by this quaternion
|
double |
squaredNorm()
Computes the square of the norm of this quaternion
|
java.lang.String |
toString()
Gets a string representation of this Quaternion for display purposes
|
void |
toUnit()
Normalizes the quaternion so that it has norm 1
|
public static final double EPSILON
public static final java.lang.String VECTOR_INVALID_LENGTH_MSG
public static final java.lang.String UNDEFINED_LOG_ZERO_QUATERNION_MSG
public static final java.lang.String INVALID_INTERPOLATION_PARAM
public Quaternion()
public Quaternion(double x, double y, double z, double w)
x
- the x coordinatey
- the y coordinatez
- the z coordinatew
- the scalar componentpublic Quaternion(Quaternion another)
another
- the Quaternion to be copiedpublic double getX()
public double getY()
public double getZ()
public double getW()
public double[] getVectorPart()
public double getScalarPart()
getW()
public double getAngle()
public double getAngleRad()
public double[] getRotationAxis()
public boolean isIdentity()
true
if this Quaternion is an identity quaternion, or
false
otherwisepublic boolean isUnit()
true
if this Quaternion is a unit quaternion, or
false
otherwisepublic boolean equals(Quaternion another, double threshold)
another
- Another Quaternion for comparisonthreshold
- A tolerance threshold valuetrue
if two Quaternions are equal within the tolerance
threshold (that means corresponding components are equal within
the tolerance threshold); false
otherwisepublic final double norm()
public final double squaredNorm()
public final void normalize()
public final void toUnit()
normalize()
public final Quaternion conjugate()
public final void conjugateEq()
public final Quaternion add(Quaternion another)
another
- The other quaternion involving in the additionpublic final void addEq(Quaternion another)
another
- The other quaternion involving in the additionpublic final Quaternion multiply(Quaternion another)
this * another
another
- The other quaternion involving in the multiplicationpublic final Quaternion multiply(double scalar)
scalar
- A constant factorpublic final void multiplyEq(Quaternion another)
this * another
. Assigns the result to this objectanother
- The other quaternion involving in the multiplicationpublic final void multiplyEq(double scalar)
scalar
- A constant factorpublic final Quaternion inverse()
public final void inverseEq()
invert()
public final void invert()
public final Quaternion divide(Quaternion another)
this / another
another
- The other quaternion involving in the divisionpublic final void divideEq(Quaternion another)
this / another
. Assigns the result to this objectanother
- The other quaternion involving in the divisionpublic final Quaternion exp()
public final Quaternion log() throws java.lang.ArithmeticException
java.lang.ArithmeticException
- if the Quaternion has norm approaching 0, that
is the norm is less than EPSILON
public final double[][] getRotationMatrix()
public final double[] rotate(double[] vector) throws java.lang.IllegalArgumentException
vector
- An array of size 3 representing a 3D vectorjava.lang.IllegalArgumentException
- if input vector is not an array of size 3public static Quaternion getIdentity()
public static Quaternion fromAxisAngle(double[] axis, double angleInDeg) throws java.lang.IllegalArgumentException
axis
- An array of size 3 representing the vector (x, y, z)angleInDeg
- The angle (in degrees) of the rotationEPSILON
, an identity Quaternion is returnedjava.lang.IllegalArgumentException
- if input vector is not an array of size 3public static Quaternion fromAxisAngleRad(double[] axis, double angleInRad) throws java.lang.IllegalArgumentException
axis
- An array of size 3 representing the vector (x, y, z)angleInRad
- The angle (in radians) of the rotationEPSILON
, an identity Quaternion is returnedjava.lang.IllegalArgumentException
- if input vector is not an array of size 3public static Quaternion fromEulerAngles(double roll, double pitch, double yaw)
roll
- The roll angle (in radians)pitch
- The pitch angle (in radians)yaw
- The yaw angle (in radians)roll
,
pitch
, yaw
anglespublic static Quaternion lerp(Quaternion from, Quaternion to, double t) throws java.lang.IllegalArgumentException
from
and to
Quaternion. When
t = 1
, the to
Quaternion is returned. When t = 0
,
the from
Quaternion is returnedfrom
- The first Quaternionto
- The second Quaterniont
- Value indicating how far to interpolate between the two
Quaternionsjava.lang.IllegalArgumentException
- if t
is not between 0 and 1
inclusivelypublic java.lang.String toString()
toString
in class java.lang.Object
public boolean equals(java.lang.Object another)
equals
in class java.lang.Object
public int hashCode()
hashCode
in class java.lang.Object


--- layout: v3 title: Docs ---
The goal of App.js is to provide a robust starting point for mobile webapps, handling general scenarios, and maintaining compatiblity with other common JavaScript libraries.
Make sure to download the App.js bundle before proceeding. It'll serve as a starting point for building your app.
Unzip the bundle and open up index.html
Below is the standard format for App.js webpages:
<!DOCTYPE html>   <title>My App</title> <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, minimal-ui"> <link rel="stylesheet" href="//cdn.kik.com/app/3.0.0/app.min.css">
Things to note:
app.min.js
is the core module containing all library functionality.app.min.css
is the default stylesheet provided with App.js. It contains iOS/Android styles for all included widgets.zepto.min.js
is jQuery-like library focusing on being lightweight and mobile-friendly. It is not a dependency for App.js but still nice to have for writing concise, cross-platform code. Replace this with jQuery if you so desire.Since App.js apps are fundamentally static all you have to do is put your code in an HTML file and open it in a browser to test.
It is advised that you run your app in Chrome while simulating a mobile platform that you're targeting. Don't forget to turn on touch event emulation.
You can alternatively fork our Image Search example and start with an already existing product.
App.js is built to serve makers of static single-page apps. This means that it keeps all page navigation within the session of the webpage, defining "pages" as DOM nodes that can be instantiated.
Pages are HTML elements that have certain generic components like a topbar and content area. Note that while these components are completely optional the "app-page" format is the only requirement of your HTML.

The "app-page" must have a "data-page" attribute that denotes the name of the page. This name is used whenever any JavaScript code tries to load the page.
App.load('home');
This single line of JavaScript instructs App.js to load the page named "home". Under the hood, App.js clones the HTML "app-page" element with that name and makes it visible to the user. This way we can create multiple instances of the same page and use it in different contexts.
Whenever a new page is being loaded using "App.load" a special function is called to prepare your HTML page app-page element. This allows you to hook up any dynamic aspects of your page prior to it being shown to the user. For example, buttons can be bound to perform whatever action they need to do.
/* in your javascript */ App.controller('home', function (page) { // this runs whenever a 'home' page is loaded // 'page' is the HTML app-page element $(page) .find('.app-button') .on('click', function () { console.log('button was clicked!'); }); });
The controller can also be a JavaScript so that you can have controllers that inherit from eachother.
function HomeController(page) { // this runs whenever a 'home' page is loaded this.foo = 'bar'; this.print(); } HomeController.prototype.print = function () { console.log(this.foo); }; App.controller('home', HomeController);
If you have described multiple pages in your HTML, you will want to create a controller for each of them so that they can be constructed properly whenever loaded.
Controllers can have dynamic arguments so that you can construct a page slightly different depending on the input. For example, if I am creating a contact list app I will want to load a contact page for any given contact in my list. What we will do is describe a generic contact page with blank fields and fill them in depending on which contact the page is being loaded for.
To load a page with special arguments simply add an JSON object to the "App.load" call and you'll be able to use that object in the populator accordingly.

Contact

/* in your javascript */ App.controller('contact', function (page, contact) { $(page).find('.first-name').text(contact.firstName); $(page).find('.last-name' ).text(contact.lastName ); });
/* somewhere else in javascript */ var contact = { firstName : 'Bruce' , lastName : 'Lee' }; App.load('contact', contact);
In the second last line of code above, the "contact" object could have any first / last name and the controller would setup the page accordingly.
These kinds of arguments coupled with Zepto or jQuery combine to effectively let you template your HTML.
Templating HTML elements is a very common paradigm, and while App.js doesn't have any dedicated features regarding templating it definitely does not get in the way. You can generally use any framework/library that you want and if you want to do it without any of those there are patterns that make it easy:

Contact

/* in your javascript */ App.controller('contact', function (page, contacts) { var $template = $(page).find('.contact').remove(); var $contacts = $(page).find('.contacts'); contacts.forEach(function (contact) { var $contact = $template.clone(true); $contact.find('.first-name').text(contact.firstName); $contact.find('.last-name' ).text(contact.lastName ); $contacts.append($contact); }); });
There are various events that App.js will fire on your page.
false
in the handler for the event (similar to how window.onbeforeunload
works).appShow
is called on the page. It has the added bonus on ensuring that window.onload
has been called, making it useful for network-bound initialization code.To handle these events, bind to them in your controllers.
App.controller('home', function (page) { $(page).on('appShow', function () { console.log('the user can see it!'); }); });
Alternatively, all events can be bound as methods of the controller class.
function HomeController(page) { // stuff } HomeController.prototype.onShow = function () { console.log('the user can see it'); }; App.controller('home', HomeController);
Upon destruction, it is important to unbind events that have been bound outside the scope of the page to allow the JavaScript garbage collector to do its job.
App.controller('home', function (page) { function doStuff() { // handle event } window.addEventListener('keypress', doStuff); $(page).on('appDestroy', function () { window.removeEventListener('keypress', doStuff); }); });
As discussed earlier, App.load
makes clone of the chosen page, creates a controller for it, and then presents it to the user.
App.load('home');
This can be called from anywhere in your code at any time. If a navigation is attempted while one is in progress the navigation will be queued to perform after the current one completes.
Additionally, a callback can be provided to be run when the navigation is complete.
App.load('home', function () { // done! });
Because buttons often directly load pages there is a feature to allow this is a quick, succinct way.

Go to page 2

Open contact

When the first button is clicked App.load('page2')
will automatically get called. The second button is similar but also provides page arguments to be pass along (App.load('contact', { firstName : 'Bruce' , lastName : 'Lee' })
)
As you navigate from page to page App.js mantains a history of the pages you have been to with the ability to navigate back to them. App.back
is the conceptual reverse of App.load
in that navigates back to the previous page load (destroying the current page when the navigation completes).
// load home // load page2 App.back(function () { // back to home // page2's appDestroy event has been called });
If there is no prior page to navigate back to App.back
will return false
.
As with the data-target
feature, there is a conceptually reverse feature for App.back
.

Go back

When the above button is clicked App.back()
will automatically get called.
It is common to go back to a specific page rather than simply back a single page.
// load home // load page2 // load page3 App.back('home', function () { // back to home // page2's and page3's appDestroy events have been called });
Another common thing to do with a back button is name it based on the previous page. App.js provides a convenience for automatically having the back button be named after the page it will lead to.

A common use-case for pages is to provide a way for the user to pick some content or data to be used on the calling page. This can be done using the following:
App.controller('selector', function (page, request) { // 'request' is data from the requestor // respond to the caller // will implicitely call App.back and destroy the page this.reply({ some: 'data' }); }); App.pick('selector', { some: 'data' }, function (data) { // 'data' is the reply data // do something with it });
By default App.js will attempt to transition between pages using whatever fits best with the platform that your app is running on. For example on iOS the titles of your pages will slide while fading out, simulating the native iOS transition style.
There are many built in transitions and each call to "App.load" can specify which transition to use directly (overriding the defaults).
App.load('home', 'fade'); // fade between pages
Transitions are provided by Swapper.js. Go to the docs for the list of available transitions.
Additionally you can set the global default transition for all navigations.
App.setDefaultTransition('transition-name'); // global // set per platform App.setDefaultTransition({ ios : 'transition-name' , // iOS iosFallback : 'transition-name' , // iOS <5 android : 'transition-name' , // Android androidFallback : 'transition-name' , // Android < 4 fallback : 'transition-name' // non-iOS, non-Android });
Default transitions can also be set per-page.
App.controller('page2', function (page) { this.transition = 'fade'; });
Because App.js is aware of your navigation stack and how to construct pages, it also provides the ability to automatically restore the users session to where they were the last time it was closed. Enabling this feature requires this following idiom:
// in your apps main method try { // try to restore previous session App.restore(); } catch (err) { // else start from scratch App.load('home'); }
Below is an example of how to only restore the stack if the last session was in the last 5 minutes.
try { App.restore({ maxAge: 5*60*1000 }); } catch (err) { App.load('home'); }
Note: maxAge
is in milliseconds.
Individual pages can prevent themselves from being ever restored (for example if they are modal).
App.controller('page2', function (page) { this.restorable = false; });
page2
and any page ahead of it in the stack will not be restored (but previous pages will).
While generally a bad practice, it is often necessary to manipulate the navigation stack under-the-hood without user interaction.
Note that it is impossible to remove the currently visible page without calling App.back
or App.load
first.
// stack = [home, page2, page3] App.removeFromStack(0,1); // remove home from stack // stack = [page2, page3] App.addToStack(1, ['home', 'page4']); // add two pages at index 1 // stack = [page2, home, page4, page3]
App.js pages are generally structured with a topbar and content area. The topbar contains the title and buttons (for navigation and other actions) while the content has the actual material for the page.

App.js comes with a bunch of UI components built-in and already styled. Almost all of these will end up in your app-content
.
Note that it is often convenient to have styles that are specific to a platform. For example in the demo at the top of this page the topbar is styled slightly different on iOS and Android. To accomodate this App.js adds classes to the body of the document denoting which platform it is running on. Using this class as a filtering selector can let you have separate styles for a single widget.
.my-widget { /* cross-platform styles */ } .app-ios .my-widget { /* ios only styles */ } .app-android .my-widget { /* android only styles */ }
Like many native mobile apps, the App.js topbar generally consists of several buttons and a title.

Page title

Check out the buttons section on how to add buttons to your topbar.
The app-content
contains all of the contents of the page including buttons, lists, and inputs. While these widgets are useful, it is usually the case that the custom HTML structures of the app will go here.
By default it automatically has scrolling managed for it. To turn off automatic scrolling add the attribute data-no-scroll
to the content element.
Buttons are basic components of any app and App.js has several built-in conveniences for handling them. Any element with the class app-button
will automatically be styled accordingly, as well being very responsive to touches with appropriate downstates when pressed.

My button

One of the more common placements for buttons is in the topbar.

Back

Page title

Forward

As you might imagine, the "Back" button will show up on the left and the "Forward" on the right. You'll notice that the styles are significantly different than the button in the content area as in this context we expect a smaller button that is suitable for navigation and such.
Lists are useful for displaying bulk data or providing a set of options to choose from.

Item 1

Item 2

Item 3

Additionally list items can be buttons.

Button item

Lists often have labels to segment items into logical sections.

 Animals
Dogs

Cats
 Fruits
Apples

Oranges

Lists often create the need for dynamically loaded content as the user scrolls. App.js can handle this for you.
App.infiniteScroll(listElement, function (next) { // dynamically fetch data var list = []; // add html elements to list next(list); });
Note that listElement
is the HTML element that will have element dynamically inserted into.
Having a loading element present while waiting for dynamic content to load is a common use-case.
App.infiniteScroll(listElement, { loading: loadingElem }, function (next) { next([ stuff ]); });
Note that loadingElem
will be cloned and used at the bottom of the list while content is being fetched.
App.js provides standard components to gather user input, from either HTML inputs or textareas, making it easy to construct forms.
 <input class="app-input"> <input type="search" class="app-input">  <textarea class="app-input"></textarea>
"Sections" is a concept in the App.js UI that lets you separate blocks of components into convenient.. well.. sections.
Try this out in the content of your app:

 <input class="app-input" placeholder="Subject"> <textarea class="app-input" placeholder="Message"></textarea>
Send

You'll notice that the very same inputs that were described above are now in a rounded section all to themselves. Additionally, there is a margin around the section as well as appropriate borders. These features can be applied to any of the described widgets that go in the content area of your page.

Item 1

Item 2

Item 3

Send

 <input class="app-input">

Notice that you can put as many widgets as you like in a section and they will be handled accordingly.
App.js dialogs perform a similar duty as traditional modal dialogs and action sheets. They are modals that can present text (or HTML element) to the user with buttons to choose from to dismiss.
App.dialog({ title : 'Network Error', text : 'Looks like the connection is flaky. Try again in a bit' okButton : 'Try Again', cancelButton : 'Cancel' }, function (tryAgain) { if (tryAgain) { // try again } });
PhotoViewer.js is customizable photo gallery for App.js that is trivial to setup. It is native-feeling with swipe gestures, pinch-to-zoom and more.

Viewer

// in your js App.controller('viewer', function (page, data) { var photoViewer = new PhotoViewer(page, data.urls); });
// to use the viewer App.load('viewer', { urls: [ 'http://i.imgur.com/yDK68Ff.jpg', 'http://i.imgur.com/rKIESYd.jpg', 'http://i.imgur.com/OTaodxO.jpg' ] });
Read the PhotoViewer documentation for more options and customizations.


During the past 20 years, insists the technology and quality principle to develop and produce the crushing plant and beneficiation equipment. Moreover, we absorb the advanced technology from America and Germany to improve our production level and we also import the first class production technology and management system.
Customizable Services ? Contact us
Sign up and get our Promotional Information!
Click Here !
Copyright © 2007-2014 MiningTech
Confidentiality of customers' information is our utmost concern


{% load bootstrap3 %}
There are unsaved changes to the current email batch template. By pressing "Copy", these changes will be lost on the original email batch template and will not be on the new email batch template either. If you would like to save those changes, please cancel and save those changes before copying.
New Email Batch Template Name:


Insert @ anywhere to start mentioning. Press enter to stop and insert the mention subject. Press escape to cancel mentioning.
span text bold em text
text below
Your mention keyword is:


--- layout: page title: About date: 2013-06-01 14:18:48.000000000 +09:00 type: page parent_id: '0' published: true password: '' status: publish categories: [] tags: [] meta: {} author: login: mouthless email<EMAIL_ADDRESS>display_name: mouthless first_name: '' last_name: '' ---
This is an example of a page. Unlike posts, which are displayed on your blog’s front page in the order they’re published, pages are better suited for more timeless content that you want to be easily accessible, like your About or Contact information. Click the Edit link to make changes to this page or add another page.


Protocols
The following protocols are available globally.
-
Type Erasure for
See moreConnectedNodeDescription
Declaration
Swift
public protocol AnyConnectedNodeDescription
-
In applications developed with Katana, the application information is stored in a central Store. There are cases where you want to take pieces of information from the central store and use them in your UI.
ConnectedNodeDescription
is the protocol that is used to implement this behaviour.By implementing this protocol in a description you get two behaviours: store information merging and automatic UI update.
Merge description’s props and Store’s state
Every time there is an UI update (e.g., because either props or state are changed), Katana allows you to inject in the props information that are taken from the central Store. You can use the
connect
method to implement this behaviour.Automatic UI update
Every time the Store’s state changes, you may want to update the UI. When you adopt the
ConnectedNodeDescription
protocol, Katana will trigger an UI update to all the nodes that are related to the description. The system will search for all the nodes that have a description that implements this protocol. It will then calculate the new props, by invokingconnect
. If the properties are changed, then the UI update is triggered. In this way we are able to effectively trigger UI changes only where and when needed.See moreSee also
Store
Declaration
Swift
public protocol ConnectedNodeDescription: AnyConnectedNodeDescription, NodeDescription
-
An action represents an event that leads to a change in the state of the application. It can be triggered from a user action, from a system event or any event in general.
In general this protocol should not be used directly. Use
See moreSyncAction
andAsyncAction
insteadDeclaration
Swift
public protocol Action
-
Type Erasure for
See moreNodeDescriptionWithChildren
Declaration
Swift
public protocol AnyNodeDescriptionWithChildren: AnyNodeDescription
-
This is the protocol that descriptions (that is, concrete implementations of
NodeDescription
) need to implement if they contain children. For example theView
component ofKatanaElements
implements this protocol and it allows to implement the following behaviour:func childrenDescriptions(...) { View(props: ViewProps()) { return [ Image(props: ImageProps()), Button(props: ButtonProps()), ] } }
Basically we can return a View description that holds some children.
Katana will internally leverage this protocol to correctly handle the children (e.g., render and apply the layout).
See moreDeclaration
Swift
public protocol NodeDescriptionWithChildren: NodeDescription, AnyNodeDescriptionWithChildren
-
This protocol is used for properties of descriptions that implement the
See moreNodeDescriptionWithChildren
protocolDeclaration
Swift
public protocol Childrenable
-
Type Erasure for
See moreNodeDescriptionProps
Declaration
Swift
public protocol AnyNodeDescriptionProps
-
Protocol that is used for structs that represent the properties of a
NodeDescription
.This protocol requires instances to be equatable. Katana uses this requirement to avoid to update the UI if the properties (and the state) are not changed.
See moreDeclaration
Swift
public protocol NodeDescriptionProps: AnyNodeDescriptionProps, Equatable
-
Type Erasure for the
See moreNodeDescription
protocolDeclaration
Swift
public protocol AnyNodeDescription
-
A
NodeDescription
defines a specific piece of UI. You can think of aNodeDescription
as a stencil that describes how a piece of UI should look like.NodeDescription
methods are stateless. This is because the properties and the state are held by aNode
instance (seeNode
for more information) that Katana automatically creates.In general, a description defines two things:
how properties and state are used to personalise the instance of UIView/NSView (or subclass) associated with the
Node
instance. This view is also named NativeViewwhat are the children descriptions given the properties and the state
Node and NodeDescription relationship
It is important to remember that the UI hierarchy has a 1:1 relationship with
Node
instances and not withNodeDescription
. This means that eachUIView
in the UIKit UI tree (orNSView
in the AppKit UI tree) is connected to aNode
instance. This instance holds the description that is used to manage theUIView
(orNSView
) (and the children), properties and the state.This is why all the
See moreNodeDescription
methods are static. Description instances are meaningless and are used only as an easy to ready way to describe the UI in thechildrenDescriptions(props:state:update:dispatch:)
method. These instances are used by Katana to understand how to update the UI (update, remove and add views) and then thrown away.Declaration
Swift
public protocol NodeDescription: AnyNodeDescription
-
Declaration
Swift
public protocol AnyNode: class
-
Protocol that the side effect dependencies container should implement
See moreDeclaration
Swift
public protocol SideEffectDependencyContainer: class
-
This protocol abstracts how
Node
instances can be rendered. We have introduced this protocol to abstract the Katana world (nodes and descriptions) from the underlying implementation of how the UI is rendered.The most obvious implementation of this protocol is
See moreUIView
for iOS orNSView
for mac OS. It is possible to create custom containers that renders nodes on abstract structures (e.g., for testing) or on serializable structures to store the UI representation and use it later.Declaration
Swift
public protocol PlatformNativeView : class
-
Protocol that
NodeDescription
implementations can adopt to provide a reference size.Reference Size is used to calculate the Plastic multiplier. For a given node, the multiplier is calculated in the following way:
find the closest ancestor in the nodes tree
calculate the height multiplier:
ancestor.size.height / ancestor.description.referenceSize.height
calculate the width multiplier:
ancestor.size.width / ancestor.description.referenceSize.width
the Plastic multiplier is the minimum of the two
Declaration
Swift
public protocol PlasticReferenceSizeable
-
Protocol for the state of the applications. In Katana, all the relevant application information should be placed in a single struct that has to implement the
See moreState
protocol.Declaration
Swift
public protocol State
-
Action
can implement this protocol to perform side effects when an instance is dispatched.A side effect is nothing more than a piece of code that can interact with external services or APIs (e.g., make a network request, get information from the disk and so on). Side effects are needed because the
updatedState(currentState:)
function (which is the only other operation that is performed when an action is dispatched) must be pure and therefore it cannot interact with disk, network and so on.Dependencies
You can see from the
See moresideEffect(currentState:previousState:dispatch:dependencies:)
signature that a side effect takes as input some dependencies. This is a form of dependency injection for the side effects. By using only methods coming from the dependencies (instead of relying on global imports), testing is much more easier since you can inject a mocked version of the things you need in the side effect. For example, in a test, you may want to inject a mocked version of the class that manages the API requests, in order to control the result of the network call.Declaration
Swift
public protocol ActionWithSideEffect: Action
-
Type Erasure for
See morePlasticNodeDescription
Declaration
Swift
public protocol AnyPlasticNodeDescription
-
This protocol allows a
See moreNodeDescription
to use the Plastic layout system.Declaration
Swift
public protocol PlasticNodeDescription: AnyPlasticNodeDescription, NodeDescription
-
Declaration
Swift
public protocol AnyStore: class
-
Type Erasure for
See moreAsyncAction
Declaration
Swift
public protocol AnyAsyncAction
-
Protocol that represents an
async
action.An
AsyncAction
is just an abstraction overAction
that provides a way to structure your action.You typically use an
Async
action when you have to deal with operations that are asynchronous. In the most common scenario, you dispatch the initial action, execute an operation in the side effect and then dispatch a completed/failed action based on the result of the operation. If the action has a concept of progress, you can also dispatch progress actions.This protocol has as the main goal to standardize the way async actions are managed.
It is important to note that this is just a a convenience approach to something you can do anyway. You can for instance create three actions:
performOperation
,OperationCompleted
andOperationFailed
and achieve the same result.AsyncAction
just provide a way to abstract and simplify the processTip & Tricks
Since the
Action
protocol is very generic when it comes to the state type that should be updated, a pattern we want to promote is to put in your application a protocol like the following:protocol AppSyncAction: AsyncAction { func updatedStateForLoading(currentState: inout AppState) // same for completed, failed and progress } extension AppSyncAction { func updatedStateForLoading(currentState: State) -> State { guard var state = state as? AppState else { fatalError("Something went wrong") } self.updatedStateForLoading(currentState: &state) return state } // same for completed, failed and progress }
In this way you can save a lot of code since you can use your actions in the following way
See morestruct A: AppAsyncAction { func updatedStateForLoading(currentState: inout AppState) { state.props = action.payload } // same for completed, failed and progress }
Declaration
Swift
public protocol AsyncAction: Action, AnyAsyncAction


<#include "include/common-menu.ftl"/>
<#include "include/resource-script.ftl"/>
#include "include/resource-head.ftl"/>
<#include "include/common-top.ftl"/>


Configure LDAP settings and manage role groups.
A CA certificate and LDAP certificate are required. One or more are missing.
Go to SSL certificates
Field is required
Must start with {{ldapProperties.useSSL ? 'ldaps://' : 'ldap://'}}


The Analytical PMAX Calculator is a web-based tool for determining the point of unit elasticity. This calculator streamlines the determination of an exact (Analytic) unit elasticity (i.e., slope = -1) using a simple, copy-paste interface. Both the Approximate and Exact (Analytic) PMAX measures are provided here, though only the Analytic method is considered exact.
Accepted:
Gilroy, S. P., Kaplan, B. A., Reed, D. D., Hantula, D. A., & Hursh, S. R. (2019). An Exact Solution for Unit Elasticity in the Exponential Model of Demand. Journal of Experimental and Clinical Psychopharmacology. doi: 10.1037/pha0000268
This calculator evaluates models of operant demand (see Hursh & Silberberg, 2008) to determine a point where one log-unit increase in price corresponds to a one log-unit decrease in consumption, i.e., PMAX. This has be done using numerical approximations or through more computationally-exhaustive iterative methods, using the first order derivative, but newer exact solution (Analytic) methods now exist.
To calculate exact solution PMAX, you may paste the fitted Q0, alpha, and K parameters from the model of demand into the spreadsheet component (in their respective columns). Once entered, simply press the "Calculate" button to calculate the Analytical PMAX. Additionally, the Approxiate PMAX will also be outputted in the spreadsheet component, in its respective column, though users are recommended to refer to the exact approach whenever possible.
Optionally, you may preview this method using a sample data by pressing the "Load Sample Data" button and then pressing "Calculate". This will let you view the differences between the Approximate and Analytical PMAX.
The PMAX Calculator uses the following tools to function:


|
My Project
|
I2C driver modules. More...
Modules | |
| I2C_Private_Functions | |
| I2C_Exported_Constants | |
Data Structures | |
| struct | I2C_InitTypeDef |
| I2C Init structure definition More... | |
Functions | |
| void | I2C_DeInit (I2C_TypeDef *I2Cx) |
| Deinitialize the I2Cx peripheral registers to their default reset values. More... | |
| void | I2C_Init (I2C_TypeDef *I2Cx, I2C_InitTypeDef *I2C_InitStruct) |
| Initializes the I2Cx peripheral according to the specified parameters in the I2C_InitStruct. More... | |
| void | I2C_StructInit (I2C_InitTypeDef *I2C_InitStruct) |
| Fills each I2C_InitStruct member with its default value. More... | |
| void | I2C_Cmd (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Enables or disables the specified I2C peripheral. More... | |
| void | I2C_DigitalFilterConfig (I2C_TypeDef *I2Cx, uint16_t I2C_DigitalFilter) |
| Configures the Digital noise filter of I2C peripheral. More... | |
| void | I2C_AnalogFilterCmd (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Enables or disables the Analog filter of I2C peripheral. More... | |
| void | I2C_GenerateSTART (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Generates I2Cx communication START condition. More... | |
| void | I2C_GenerateSTOP (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Generates I2Cx communication STOP condition. More... | |
| void | I2C_Send7bitAddress (I2C_TypeDef *I2Cx, uint8_t Address, uint8_t I2C_Direction) |
| Transmits the address byte to select the slave device. More... | |
| void | I2C_AcknowledgeConfig (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Enables or disables the specified I2C acknowledge feature. More... | |
| void | I2C_OwnAddress2Config (I2C_TypeDef *I2Cx, uint8_t Address) |
| Configures the specified I2C own address2. More... | |
| void | I2C_DualAddressCmd (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Enables or disables the specified I2C dual addressing mode. More... | |
| void | I2C_GeneralCallCmd (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Enables or disables the specified I2C general call feature. More... | |
| void | I2C_SoftwareResetCmd (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Enables or disables the specified I2C software reset. More... | |
| void | I2C_StretchClockCmd (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Enables or disables the specified I2C Clock stretching. More... | |
| void | I2C_FastModeDutyCycleConfig (I2C_TypeDef *I2Cx, uint16_t I2C_DutyCycle) |
| Selects the specified I2C fast mode duty cycle. More... | |
| void | I2C_NACKPositionConfig (I2C_TypeDef *I2Cx, uint16_t I2C_NACKPosition) |
| Selects the specified I2C NACK position in master receiver mode. More... | |
| void | I2C_SMBusAlertConfig (I2C_TypeDef *I2Cx, uint16_t I2C_SMBusAlert) |
| Drives the SMBusAlert pin high or low for the specified I2C. More... | |
| void | I2C_ARPCmd (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Enables or disables the specified I2C ARP. More... | |
| void | I2C_SendData (I2C_TypeDef *I2Cx, uint8_t Data) |
| Sends a data byte through the I2Cx peripheral. More... | |
| uint8_t | I2C_ReceiveData (I2C_TypeDef *I2Cx) |
| Returns the most recent received data by the I2Cx peripheral. More... | |
| void | I2C_TransmitPEC (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Enables or disables the specified I2C PEC transfer. More... | |
| void | I2C_PECPositionConfig (I2C_TypeDef *I2Cx, uint16_t I2C_PECPosition) |
| Selects the specified I2C PEC position. More... | |
| void | I2C_CalculatePEC (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Enables or disables the PEC value calculation of the transferred bytes. More... | |
| uint8_t | I2C_GetPEC (I2C_TypeDef *I2Cx) |
| Returns the PEC value for the specified I2C. More... | |
| void | I2C_DMACmd (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Enables or disables the specified I2C DMA requests. More... | |
| void | I2C_DMALastTransferCmd (I2C_TypeDef *I2Cx, FunctionalState NewState) |
| Specifies that the next DMA transfer is the last one. More... | |
| uint16_t | I2C_ReadRegister (I2C_TypeDef *I2Cx, uint8_t I2C_Register) |
| Reads the specified I2C register and returns its value. More... | |
| void | I2C_ITConfig (I2C_TypeDef *I2Cx, uint16_t I2C_IT, FunctionalState NewState) |
| Enables or disables the specified I2C interrupts. More... | |
| ErrorStatus | I2C_CheckEvent (I2C_TypeDef *I2Cx, uint32_t I2C_EVENT) |
| Checks whether the last I2Cx Event is equal to the one passed as parameter. More... | |
| uint32_t | I2C_GetLastEvent (I2C_TypeDef *I2Cx) |
| Returns the last I2Cx Event. More... | |
| FlagStatus | I2C_GetFlagStatus (I2C_TypeDef *I2Cx, uint32_t I2C_FLAG) |
| Checks whether the specified I2C flag is set or not. More... | |
| void | I2C_ClearFlag (I2C_TypeDef *I2Cx, uint32_t I2C_FLAG) |
| Clears the I2Cx's pending flags. More... | |
| ITStatus | I2C_GetITStatus (I2C_TypeDef *I2Cx, uint32_t I2C_IT) |
| Checks whether the specified I2C interrupt has occurred or not. More... | |
| void | I2C_ClearITPendingBit (I2C_TypeDef *I2Cx, uint32_t I2C_IT) |
| Clears the I2Cx's interrupt pending bits. More... | |
I2C driver modules.
| void I2C_AcknowledgeConfig | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Enables or disables the specified I2C acknowledge feature.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2C Acknowledgement. This parameter can be: ENABLE or DISABLE. |
| None. |
| void I2C_AnalogFilterCmd | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Enables or disables the Analog filter of I2C peripheral.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the Analog filter. This parameter can be: ENABLE or DISABLE. |
| None |
| void I2C_ARPCmd | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Enables or disables the specified I2C ARP.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2Cx ARP. This parameter can be: ENABLE or DISABLE. |
| None |
| void I2C_CalculatePEC | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Enables or disables the PEC value calculation of the transferred bytes.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2Cx PEC value calculation. This parameter can be: ENABLE or DISABLE. |
| None |
| ErrorStatus I2C_CheckEvent | ( | I2C_TypeDef * | I2Cx, |
| uint32_t | I2C_EVENT | ||
| ) |
Checks whether the last I2Cx Event is equal to the one passed as parameter.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_EVENT | specifies the event to be checked. This parameter can be one of the following values:
|
| An | ErrorStatus enumeration value:
|
| void I2C_ClearFlag | ( | I2C_TypeDef * | I2Cx, |
| uint32_t | I2C_FLAG | ||
| ) |
Clears the I2Cx's pending flags.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_FLAG | specifies the flag to clear. This parameter can be any combination of the following values:
|
| None |
| void I2C_ClearITPendingBit | ( | I2C_TypeDef * | I2Cx, |
| uint32_t | I2C_IT | ||
| ) |
Clears the I2Cx's interrupt pending bits.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_IT | specifies the interrupt pending bit to clear. This parameter can be any combination of the following values:
|
| None |
| void I2C_Cmd | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Enables or disables the specified I2C peripheral.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2Cx peripheral. This parameter can be: ENABLE or DISABLE. |
| None |
| void I2C_DeInit | ( | I2C_TypeDef * | I2Cx | ) |
Deinitialize the I2Cx peripheral registers to their default reset values.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| None |
| void I2C_DigitalFilterConfig | ( | I2C_TypeDef * | I2Cx, |
| uint16_t | I2C_DigitalFilter | ||
| ) |
Configures the Digital noise filter of I2C peripheral.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_DigitalFilter | Coefficient of digital noise filter. This parameter can be a number between 0x00 and 0x0F. |
| None |
| void I2C_DMACmd | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Enables or disables the specified I2C DMA requests.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2C DMA transfer. This parameter can be: ENABLE or DISABLE. |
| None |
| void I2C_DMALastTransferCmd | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Specifies that the next DMA transfer is the last one.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2C DMA last transfer. This parameter can be: ENABLE or DISABLE. |
| None |
| void I2C_DualAddressCmd | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Enables or disables the specified I2C dual addressing mode.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2C dual addressing mode. This parameter can be: ENABLE or DISABLE. |
| None |
| void I2C_FastModeDutyCycleConfig | ( | I2C_TypeDef * | I2Cx, |
| uint16_t | I2C_DutyCycle | ||
| ) |
Selects the specified I2C fast mode duty cycle.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_DutyCycle | specifies the fast mode duty cycle. This parameter can be one of the following values:
|
| None |
| void I2C_GeneralCallCmd | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Enables or disables the specified I2C general call feature.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2C General call. This parameter can be: ENABLE or DISABLE. |
| None |
| void I2C_GenerateSTART | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Generates I2Cx communication START condition.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2C START condition generation. This parameter can be: ENABLE or DISABLE. |
| None. |
| void I2C_GenerateSTOP | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Generates I2Cx communication STOP condition.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2C STOP condition generation. This parameter can be: ENABLE or DISABLE. |
| None. |
| FlagStatus I2C_GetFlagStatus | ( | I2C_TypeDef * | I2Cx, |
| uint32_t | I2C_FLAG | ||
| ) |
Checks whether the specified I2C flag is set or not.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_FLAG | specifies the flag to check. This parameter can be one of the following values:
|
| The | new state of I2C_FLAG (SET or RESET). |
| ITStatus I2C_GetITStatus | ( | I2C_TypeDef * | I2Cx, |
| uint32_t | I2C_IT | ||
| ) |
Checks whether the specified I2C interrupt has occurred or not.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_IT | specifies the interrupt source to check. This parameter can be one of the following values:
|
| The | new state of I2C_IT (SET or RESET). |
| uint32_t I2C_GetLastEvent | ( | I2C_TypeDef * | I2Cx | ) |
Returns the last I2Cx Event.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| The | last event |
| uint8_t I2C_GetPEC | ( | I2C_TypeDef * | I2Cx | ) |
Returns the PEC value for the specified I2C.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| The | PEC value. |
| void I2C_Init | ( | I2C_TypeDef * | I2Cx, |
| I2C_InitTypeDef * | I2C_InitStruct | ||
| ) |
Initializes the I2Cx peripheral according to the specified parameters in the I2C_InitStruct.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_InitStruct | pointer to a I2C_InitTypeDef structure that contains the configuration information for the specified I2C peripheral. |
| None |
| void I2C_ITConfig | ( | I2C_TypeDef * | I2Cx, |
| uint16_t | I2C_IT, | ||
| FunctionalState | NewState | ||
| ) |
Enables or disables the specified I2C interrupts.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_IT | specifies the I2C interrupts sources to be enabled or disabled. This parameter can be any combination of the following values:
|
| NewState | new state of the specified I2C interrupts. This parameter can be: ENABLE or DISABLE. |
| None |
| void I2C_NACKPositionConfig | ( | I2C_TypeDef * | I2Cx, |
| uint16_t | I2C_NACKPosition | ||
| ) |
Selects the specified I2C NACK position in master receiver mode.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_NACKPosition | specifies the NACK position. This parameter can be one of the following values:
|
| None |
| void I2C_OwnAddress2Config | ( | I2C_TypeDef * | I2Cx, |
| uint8_t | Address | ||
| ) |
Configures the specified I2C own address2.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| Address | specifies the 7bit I2C own address2. |
| None. |
| void I2C_PECPositionConfig | ( | I2C_TypeDef * | I2Cx, |
| uint16_t | I2C_PECPosition | ||
| ) |
Selects the specified I2C PEC position.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_PECPosition | specifies the PEC position. This parameter can be one of the following values:
|
| None |
| uint16_t I2C_ReadRegister | ( | I2C_TypeDef * | I2Cx, |
| uint8_t | I2C_Register | ||
| ) |
Reads the specified I2C register and returns its value.
| I2C_Register | specifies the register to read. This parameter can be one of the following values:
|
| The | value of the read register. |
| uint8_t I2C_ReceiveData | ( | I2C_TypeDef * | I2Cx | ) |
Returns the most recent received data by the I2Cx peripheral.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| The | value of the received data. |
| void I2C_Send7bitAddress | ( | I2C_TypeDef * | I2Cx, |
| uint8_t | Address, | ||
| uint8_t | I2C_Direction | ||
| ) |
Transmits the address byte to select the slave device.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| Address | specifies the slave address which will be transmitted |
| I2C_Direction | specifies whether the I2C device will be a Transmitter or a Receiver. This parameter can be one of the following values
|
| None. |
| void I2C_SendData | ( | I2C_TypeDef * | I2Cx, |
| uint8_t | Data | ||
| ) |
Sends a data byte through the I2Cx peripheral.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| Data | Byte to be transmitted.. |
| None |
| void I2C_SMBusAlertConfig | ( | I2C_TypeDef * | I2Cx, |
| uint16_t | I2C_SMBusAlert | ||
| ) |
Drives the SMBusAlert pin high or low for the specified I2C.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| I2C_SMBusAlert | specifies SMBAlert pin level. This parameter can be one of the following values:
|
| None |
| void I2C_SoftwareResetCmd | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Enables or disables the specified I2C software reset.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2C software reset. This parameter can be: ENABLE or DISABLE. |
| None |
| void I2C_StretchClockCmd | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Enables or disables the specified I2C Clock stretching.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2Cx Clock stretching. This parameter can be: ENABLE or DISABLE. |
| None |
| void I2C_StructInit | ( | I2C_InitTypeDef * | I2C_InitStruct | ) |
Fills each I2C_InitStruct member with its default value.
| I2C_InitStruct | pointer to an I2C_InitTypeDef structure which will be initialized. |
| None |
| void I2C_TransmitPEC | ( | I2C_TypeDef * | I2Cx, |
| FunctionalState | NewState | ||
| ) |
Enables or disables the specified I2C PEC transfer.
| I2Cx | where x can be 1, 2 or 3 to select the I2C peripheral. |
| NewState | new state of the I2C PEC transmission. This parameter can be: ENABLE or DISABLE. |
| None |


by Santosh Pradhan on August 24, 2017
Salesforce Einstein Vision - A Starter Kit to Image Recognition
Einstein Vision has been one of the cool topics recently. Why!?
Sixt Gmbh & Co Automoviertung KG
Munich, Germany (Apr 2016 - Now)BMC Software
Bangalore, India (Jan 2015 - Mar 2016)Deloitte Digital
Bangalore, India (Nov 2013 - Dec 2014)Tata Consultancy Services
Bangalore, India (Mar 2011 - Nov 2013)I wrote some articles about whatever was on our heads and most people liked it.
Einstein Vision has been one of the cool topics recently. Why!?
I am sure you all have come across and may already be using tools for deployment process, like - Git or Bitbucket for Source Control
Create Chrome Extension that reads classes, pages from Salesforce.
Send me your inquiry, I will help you and reply as soon as possible
You can send me something like a question or call request, I am open 09:00 to 17:00 on weekends.


Why a Housing Data Hub?
The Housing Data Hub was born out of a need to have a single place to learn:
- What is the City of Sacramento doing about affordable housing?
- What data is available about each of the policies and programs related to affordable housing?
We wanted to enrich the content about the housing programs with their supporting data. We hope that readily available content, data and visuals spurs new thinking and approaches to affordable housing in the City.
A process of continuous improvement
Our philosophy is that it is better to release something sooner versus waiting for a perfect launch. We are releasing our datasets in phases.
Code for San Francisco
This version of the website was derived from the fantastic work that Code for San Francisco did with their Housing Data Hub. Their hard work made it possible to stand this site up with limited resources and to get the discussion started.
Open source community
This project is built on some incredible open source tools and inspirations that made our job a whole lot easier:
- Jekyll is our static site compiler of choice. It has served us well and it allows us to host the Housing Data Hub on a gh-pages branch in GitHub to boot.
- jQuery is a well-supported library for manipulating the DOM and doing other neat tricks with Javascript with a little less code.
- Bootstrap 3 provides all the scaffolding and UI basics to get us going quickly.
- C3 is a wonderful library built around D3 that gives us power without complexity including beautiful easy to configure, reusable charts.
- Dave Guarino's lovely easy-choropleth project was the inspiration for the pattern we took with our choropleth mapping, but instead of Google Sheets we use trusty, reliable CSVs to power the map data.
- Colorbrewer2.org provides a tiny javascript library that lets us quickly configure Color Brewer based ramps in code, which is very helpful for choropleth maps.
- Mapbox.js is a Leaflet-based library that let's us connect quickly to our Mapbox basemaps and put data on a map.
- Leaflet Omnivore chews on CSVs and spits out mappable layers for Leaflet
- Leaflet fullscreen enables a map to go full screen so you can look at all that delicious data without distractions.
- Prose provides us with a nice framework for allowing humans to actually edit content and plays nicely with Jekyll.
Licenses
- Data released within the Housing Data Hub is licensed under the Public Domain Dedication and License.
- The source code of the site is available under the MIT License


Application Integration is a collection of technologies and services that form a middleware to enable integration of systems and applications across the enterprise.
Supply chain management applications, customer relationship management applications, business intelligence applications, and other types of applications, typically cannot communicate with one another in order to efficiently share data.
Use this pattern when:
The solution is to implement a message flow that mediates between the providing and requesting applications.


Release Notes
Earlier Releases
Release Notes for
NUnit 2.4 through 2.4.8
Release Notes for
NUnit 2.0 through 2.2.10


[gecode-users] Some distinct
Christian Schulte
cschulte at kth.se
Tue Dec 4 15:37:32 CET 2007
Hi David,
There is no real plan to implement some-distinct. But we are happy to accept
contributions (and are willing to give prime support in return for that ;-)
). The paper should be accessible through SpringerLink:
http://www.springerlink.com/content/n8226635404k1670/
However, I believe that some-different is not what you want to have. To me
it looks like count (or global cardinality) which is included in Gecode
(just after a quick look).
Cheers
Christian
--
Christian Schulte, www.ict.kth.se/~cschulte/
-----Original Message-----
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
Of David Rijsman
Sent: Tuesday, December 04, 2007 2:58 PM
To: users at gecode.org
Subject: [gecode-users] Some distinct
Are there any plans to introduce the some-distinct constraint
(Generalizing AllDifferent: the SomeDifferent Constraint,
Yossi Richter, Ari Freund and Yehuda Naveh) in Gecode? If I had access
to the paper I could see if I could do an attempt to implement this it
but if
there are plans or other ways to get the same semantics that would be
a waste of time.
My use case is the following:
For d subsequent periods I have 1,..,k(d) activities to assign to n
resources where k(d) <= n and there are all kinds of constraints
between activities in different periods assigned to the same resource.
Today I model this by introducing a variable x<i,j> for period i and
resource j with initial domain [1,..,n] where value v corresponds with
activity v in period d and all value greater than k(i) to be
non-activities.
On all the variables of the different resources in the same period I
post the distinct constraint such that the same activity does not get
assigned to the same resource.
This works as long as I interpret the values x<i,j> greater or equal
to k(i) identical in the subsequent constraints in the model also I
would need a customized branching strategy to only commit to one value
greater than k
I prefer to do the following:
Introduce a variable x<i,j> for period i and resource j with initial
domain [1,..,k(i) + 1 ] where value v less or equal to k(i)
corresponds with activity v in period d and value k(i) corresponds to
no activity.
On all the variables of the different resources in the same period I
post the some-distinct constraint such that the same activity does not
get assigned to the same resource. If value k(i) is selected it does
not have to be different from the other variables.
David Rijsman
_______________________________________________
Gecode users mailing list
users at gecode.org
https://www.gecode.org/mailman/listinfo/gecode-users
More information about the gecode-users
mailing list


Prajna Vision Hub
Page not found
Prajna Vision Hub
Prajna Vision Hub is a project of Microsoft Research,
Cloud Computing and Storage group
.
Contact us
Privacy and Cookies
Terms of use
Code of Conduct
Trademarks
Report Abuse
© 2015 Microsoft


Class InPlaceTransformationRule
Defines a simple transformation rule of a transformation that has multiple input arguments and no output
Inheritance
Inherited Members
Namespace: NMF.Transformations
Assembly: NMF.Transformations.dll
Syntax
public abstract class InPlaceTransformationRule : InPlaceTransformationRuleBase
Remarks
Simple means that the transformation rule does not require a custom computation class
Constructors
| Improve this Doc View SourceInPlaceTransformationRule()
Creates a new transformation rule
Declaration
public InPlaceTransformationRule()
Remarks
Simple means that the transformation rule does not require a custom computation class
Properties
| Improve this Doc View SourceNeedDependenciesForOutputCreation
Gets a value indicating whether the output for all dependencies must have been created before this rule creates the output
Declaration
public override bool NeedDependenciesForOutputCreation { get; }
Property Value
| Type | Description |
|---|---|
| bool |
Overrides
Remarks
Simple means that the transformation rule does not require a custom computation class
Methods
| Improve this Doc View SourceCreateComputation(object[], IComputationContext)
Creates a new Computation instance for this transformation rule or the given input
Declaration
public override Computation CreateComputation(object[] input, IComputationContext context)
Parameters
| Type | Name | Description |
|---|---|---|
| object[] | input | The input arguments for this computation |
| IComputationContext | context | The context for this computation |
Returns
| Type | Description |
|---|---|
| Computation | A computation object |
Overrides
Remarks
Simple means that the transformation rule does not require a custom computation class
Init(object[], ITransformationContext)
Initializes the transformation. This is done before any other transformation rule hits Transform
Declaration
public abstract void Init(object[] input, ITransformationContext context)
Parameters
| Type | Name | Description |
|---|---|---|
| object[] | input | The input for this transformation rule |
| ITransformationContext | context | The current transformation context |
Remarks
Simple means that the transformation rule does not require a custom computation class
Transform(object[], ITransformationContext)
Initializes the transformation output
Declaration
public abstract void Transform(object[] input, ITransformationContext context)
Parameters
| Type | Name | Description |
|---|---|---|
| object[] | input | The input of the transformation rule |
| ITransformationContext | context | The context (and trace!) object |
Remarks
At this point, all the transformation outputs are created (also the delayed ones), thus, the trace is fully reliable


{% extends "newwebpage/base.html" %} {% load static %} {% block content %}
No. Even though you can identify the most closely related proteins, you can only acquire an official name by use of this site. Self-naming of proteins will inevitably lead to different users adopting the same protein name, confusing the literature. Only the nomenclature committee can issue new protein names.
No. Xpp is a holding group containing members of several disparate protein families. As a result, Xpp-like would not actually indicate any significant homology. You could however, refer to your protein in relation to a specific Xpp protein (as Xpp37-like for example). The numeric value will be retained when the protein is re-categorized to a specific protein family in the future.
Probably not. This site only aims to deal with proteins of bacterial origin. However, if your protein of non-bacterial origin has a high degree of identity with a protein that is already in the database, you may make a case for its inclusion. The committee will consider these requests on a case-by-case basis.


skip to page content
Responsive Starter
Home
Services
Products
About
Clients
Blog
Columns
No Gutters
Offsets


Next: case, Previous: or, Up: Data and Control Flow Dictionary
when
test-form {form}* ⇒ {result}*
unless
test-form {form}* ⇒ {result}*
test-form—a form.
forms—an implicit progn.
results—the values of the forms in a when form if the test-form yields true or in an unless form if the test-form yields false; otherwise nil.
when and unless allow the execution of forms to be dependent on a single test-form.
In a when form, if the test-form yields true, the forms are evaluated in order from left to right and the values returned by the forms are returned from the when form. Otherwise, if the test-form yields false, the forms are not evaluated, and the when form returns nil.
In an unless form, if the test-form yields false, the forms are evaluated in order from left to right and the values returned by the forms are returned from the unless form. Otherwise, if the test-form yields false, the forms are not evaluated, and the unless form returns nil.
(when t 'hello) ⇒ HELLO (unless t 'hello) ⇒ NIL (when nil 'hello) ⇒ NIL (unless nil 'hello) ⇒ HELLO (when t) ⇒ NIL (unless nil) ⇒ NIL (when t (prin1 1) (prin1 2) (prin1 3)) |> 123 ⇒ 3 (unless t (prin1 1) (prin1 2) (prin1 3)) ⇒ NIL (when nil (prin1 1) (prin1 2) (prin1 3)) ⇒ NIL (unless nil (prin1 1) (prin1 2) (prin1 3)) |> 123 ⇒ 3 (let ((x 3)) (list (when (oddp x) (incf x) (list x)) (when (oddp x) (incf x) (list x)) (unless (oddp x) (incf x) (list x)) (unless (oddp x) (incf x) (list x)) (if (oddp x) (incf x) (list x)) (if (oddp x) (incf x) (list x)) (if (not (oddp x)) (incf x) (list x)) (if (not (oddp x)) (incf x) (list x)))) ⇒ ((4) NIL (5) NIL 6 (6) 7 (7))
(when test {form}^+) ≡ (and test (progn {form}^+)) (when test {form}^+) ≡ (cond (test {form}^+)) (when test {form}^+) ≡ (if test (progn {form}^+) nil) (when test {form}^+) ≡ (unless (not test) {form}^+) (unless test {form}^+) ≡ (cond ((not test) {form}^+)) (unless test {form}^+) ≡ (if test nil (progn {form}^+)) (unless test {form}^+) ≡ (when (not test) {form}^+)
Next: case, Previous: or, Up: Data and Control Flow Dictionary


--- layout: page title: Partnership permalink: /partnership/ group: navigation weight: 30 ---
Project EPIC has a strong record of publication. We have focused predominantly on venues related to HCI, CSCW and ISCRAM, but have also expanded into other specialist areas in different disciplines as the opportunities arise. Our lab is internally collaborative in its approach to research. While we are not actively seeking collaborations with external scholars, we welcome ideas for research enterprise from scholars with specific interest and ideas related to the work we do. Our dataset collections are held securely under the IRB protocol conditions and Terms of Service of the tools we access.
Within the Project EPIC research team, we look at the ways that both members of the public and formal response organizations incorporate social media into their emergency communications. We are interested in partnering with formal response organizations as they explore new ways to incorporate social media into formal response practice. Please contact us if you are interested in partnering with us.
Project EPIC currently supports graduate students from a variety of subfields of Computer Science and Linguistics with specializations including Human-Centered Computing, Software Engineering, Natural Language Processing, and Machine Learning. Our team also actively collaborates on research with students in Civil Engineering, Planning, Sociology, and Geography. If you are a current or prospective graduate student interested in learning more about Project Epic, please contact info@epic.colorado.edu.


ELB's Pathfinder Tools
NPC Gen
NPC Gen: Ex-Granlund
Weather Generator
Settlement Generator
Encounter Generator
Prices of spells are based on
spell scroll prices
multiplied by 10.
Village
Town
City
Maximum Rarity:
Common
Uncommon
Rare
Unique


This utility reduces spatial and horizontal distance to the reference ellipsoid given the geodetic latitude, longitude and ellipsoidal height of the two points. The datum code is NAD83. The user input and data ranges are defined below. The output is the ellipsoidal scale factor and ellipsoidal distance. The ellipsoidal factor is computed as a ratio between the ellipsoidal distance and the spatial or horizontal distance. The height of instrument and target are optional and may be input if required.
This utility computes the reduction of spatial directions to the reference ellipsoid given the geodetic latitude, longitude and ellipsoidal height of two points. The datum code is NAD83. The user input and data ranges are defined below. The deflection of the vertical in the north-south plane (Xi) is to be input in seconds - positive north. The deflection of the vertical in the east-west plane (Eta) is to be input in seconds - positive east. The output is the computed ellipsoidal direction.
The utility computes the reduction of astronomic azimuths to the reference ellipsoid given the geodetic latitude, longitude and ellipsoidal height of two points. The datum code is NAD83. The user input and ranges are defined below. the deflection of the vertical in the north-south plane (Xi) is to be input in seconds - positive north. The deflection of the vertical in the east-west plane (Eta) is to be input in seconds - positive east. The output is the geodetic azimuth.


Designed and developed GUI application to integrate 3 ML systems and generated automatic flows to reduce manual effort by 80%.
Visualized and analyzed music data and conducted audio processing to identify problems and improve success rate to 95%.
Built a system to generate animation of music data in piano roll with 5 speed options using Tkinter and Pygame.
Implemented and maintained Python module of MCTLab to provide music transcription in 6 instruments modes.
Created user documentation and demo to guide team members on use of systems, processes, and methodology.
Taiwan AI Academy
Dec 2019 - Apr 2020
Data Analyst
Trained CNN model to classify 24 male and female actors’ audio and video files of 8 speech and facial emotions.
Conducted data augmentation, parameters tuning, model optimization to improve accuracy to 93% on test data.
Microsoft
Aug 2016 - Jun 2019
Partner Technical Consultant
Covered Modern Workplace and Security solution including Microsoft 365 Cloud Productivity, Device Management, and Security, including Microsoft 365 tenant administration, Azure AD configuration, data loss prevention, and mail protection solutions.
Guided 300+ gold and silver partners to set up services configuration and implementation for industry scenarios including Microsoft 365, Exchanges, Business Applications, Windows, Windows Server, and Azure.
Demonstrated business opportunities with Power BI data visualization and analytical insights to successfully open new revenue streams and boost 25% profitability for 160+ CSP partners.
Communicated with stakeholders to understand business challenges and instructed 30+ partners through digital transformation to drive business opportunities including Exchange Hybrid deployment or migration to Exchange Online.
Led sessions at Microsoft Taiwan CSP Partner TechDays 2016 on SharePoint and Partner TechDays 2018 on SQL Server, two of the biggest events of Microsoft Taiwan, rewarded a 98% satisfaction rate from 304 partners.
UAVER
Jul 2015 - Sep 2015
Software Engineer Intern
Coded online support RWD applications to reduce customer support response time by 25%, using HTML5, JavaScript, CSS.
Education
Carnegie Mellon University
Aug 2020 - May 2022
Master of Science
Information Technology (Business Intelligence and Data Analytics)
National Chung-Hsing University
Sep 2012 - Jun 2016
Bachelor of Business Administrations
Management Information Systems


Files | |
| file | CacheP.h |
| Cache Handling routines for the RTOS Porting Interface. | |
Macros | |
| #define | OSAL_CACHEP_COHERENT ((uint32_t) 0U) |
| #define | OSAL_CACHEP_NOT_COHERENT ((uint32_t) 1U) |
Typedefs | |
| typedef uint32_t | Osal_CacheP_isCoherent |
| This enumerator defines the cache coherent or not. | |
Functions | |
| void | CacheP_wb (const void *addr, int32_t size) |
| Function to write back cache lines. More... | |
| void | CacheP_Inv (const void *addr, int32_t size) |
| Function to invalidate cache lines. More... | |
| void | CacheP_wbInv (const void *addr, int32_t size) |
| Function to write back and invalidate cache lines. More... | |
| void | CacheP_fenceCpu2Dma (uintptr_t addr, uint32_t size, Osal_CacheP_isCoherent isCoherent) |
| Function to call before handing over the memory buffer to DMA from CPU. More... | |
| void | CacheP_fenceDma2Cpu (uintptr_t addr, uint32_t size, Osal_CacheP_isCoherent isCoherent) |
| Function to call before reading the memory to CPU after DMA operations. More... | |
CacheP interface
| #define OSAL_CACHEP_COHERENT ((uint32_t) 0U) |
Cache is coherent on this CPU
| #define OSAL_CACHEP_NOT_COHERENT ((uint32_t) 1U) |
Cache is not coherent on this CPU
| void CacheP_fenceCpu2Dma | ( | uintptr_t | addr, |
| uint32_t | size, | ||
| Osal_CacheP_isCoherent | isCoherent | ||
| ) |
Function to call before handing over the memory buffer to DMA from CPU.
| addr | Start address of the cache line/s |
| size | size (in bytes) of the memory to be written back and invalidate |
| isCoherent | if the cache is coherent on that CPU or not |
| void CacheP_fenceDma2Cpu | ( | uintptr_t | addr, |
| uint32_t | size, | ||
| Osal_CacheP_isCoherent | isCoherent | ||
| ) |
Function to call before reading the memory to CPU after DMA operations.
| addr | Start address of the cache line/s |
| size | size (in bytes) of the memory to be written back and invalidate |
| isCoherent | if the cache is coherent on that CPU or not Osal_CacheP_isCoherent |
| void CacheP_Inv | ( | const void * | addr, |
| int32_t | size | ||
| ) |
Function to invalidate cache lines.
| addr | Start address of the cache line/s |
| size | size (in bytes) of the memory to invalidate |
| void CacheP_wb | ( | const void * | addr, |
| int32_t | size | ||
| ) |
Function to write back cache lines.
| addr | Start address of the cache line/s |
| size | size (in bytes) of the memory to be written back |
| void CacheP_wbInv | ( | const void * | addr, |
| int32_t | size | ||
| ) |
Function to write back and invalidate cache lines.
| addr | Start address of the cache line/s |
| size | size (in bytes) of the memory to be written back and invalidate |


I am a programmer, 3d artist, musician, and game designer
Programming
I enjoy programming because it allows me to create things that are useful to me and others. Projects are on my github or my personal git server
Game Development
My primary engine of choice for game development is Godot, for a multitude of reasons. I have a club at La Jolla High School called Viking Games, where we develop games to earn money towards our ASB. All of my personal games can be seen here
Modeling
I enjoy using blender to 3d model various objects and to make VFX. I also use blender to develop assets for game development. My blendswap profile is here


review_requested
by None at 2020-10-01 23:21:44.closed
by None at 2020-10-02 17:48:12.review_requested
by None at 2020-10-02 14:15:58.referenced
by Kevin Reiss at 2020-10-02 18:17:29.merged
by Kevin Reiss at 2020-10-02 18:17:29.closed
by Kevin Reiss at 2020-10-02 18:17:29.assigned
by Kevin Reiss at 2020-10-02 20:58:12.renamed
by Kevin McElwee at 2020-10-02 15:54:48.Another use case: legacy items in finding aids that have random multiple rotations. Example provided by Alexis Antricoli, and explained by Christa Cleeton: "So the issue with items like the example you noted is how they were ingested from isilon years ago. These are some of our legacy items that we had on the finding aids via webspace as well. I have been told that the only way to remedy is to re-ingest. The issue with a re-ingest is I don't always have the images saved. It has not been a priorty to fix these as you can still access them just not as cleanly as we would like. Anything that is getting ingested now does not have this issue."
Update from Alexis regarding these legacy items: We might have others like this and we are going to do a more global review and then I'll reach out.....nd none of this is a super rush, but we're hoping to get it completed by teh end of the year
Another use case: microfilm reels with rando orientations, which has happened recently. @roelmoon , can you give the title of the most recent title that colleen was working on?
mentioned
by Roel Munoz at 2020-10-02 14:31:09.subscribed
by Roel Munoz at 2020-10-02 14:31:09.referenced
by None at 2020-10-02 14:34:33.merged
by None at 2020-10-02 14:34:33.closed
by None at 2020-10-02 14:34:33.head_ref_deleted
by None at 2020-10-02 14:34:37.Coverage increased (+0.01%) to 81.947% when pulling 363c83ff27dce5d25f19434adf3ce6b159c4b8da on 266-all-available into 53c1c1f600eab225266cd1d16d18288680ec4b0c on master.
head_ref_force_pushed
by None at 2020-10-02 15:02:50.referenced
by Christina Chortaria at 2020-10-02 15:16:38.merged
by Christina Chortaria at 2020-10-02 15:16:38.closed
by Christina Chortaria at 2020-10-02 15:16:38.Items to compare ---1st --- - https://bibdata.princeton.edu/bibliographic/731418/items - mms_id:<PHONE_NUMBER>6421
--- 2nd --- - https://bibdata.princeton.edu/bibliographic/31303/items - mms_id:<PHONE_NUMBER>6421
assigned
by Christina Chortaria at 2020-10-02 13:46:45.Coverage remained the same at 81.947% when pulling f3ba3b9058dd3862834756780c64ef9b2453cf75 on more_classes into 1c2607841df715f116a0eb596beafceba03c4b49 on master.
review_requested
by Kevin Reiss at 2020-10-02 17:16:15.head_ref_force_pushed
by Kevin Reiss at 2020-10-02 17:27:23.head_ref_force_pushed
by None at 2020-10-02 17:47:04.head_ref_force_pushed
by Kevin Reiss at 2020-10-02 17:53:14.referenced
by None at 2020-10-02 17:57:46.merged
by None at 2020-10-02 17:57:47.closed
by None at 2020-10-02 17:57:47.head_ref_deleted
by None at 2020-10-02 17:57:53.assigned
by Christina Chortaria at 2020-10-02 17:19:03.labeled
by Christina Chortaria at 2020-10-02 17:19:09.closed
by None at 2020-10-02 18:50:25.renamed
by Christina Chortaria at 2020-10-02 12:38:45.This is on stgaging and someone can now retrieve an alma unsuppressed record.
example https://bibdata-staging.princeton.edu/bibliographic/991227850000541?adapter=alma
labeled
by Christina Chortaria at 2020-10-02 12:48:34.Hi there, I wanted to add some info to the description above and request some additional features. In addition to generating the AbID and barcodes, we would need the tool to go into ASpace and plug them in to the Top Container records: replacing traditional box numbers that were entered during processing and adding the barcodes.
Additionally I have been struggling with the fact that you can't add container profiles or locations to Top Containers created in ASpace using Rapid Data Entry or the spreadsheet importer. We would likely need to add both of these to every Top Container record, and so I'm wondering if this is something we could add to the tool, since the data is going to the same place in ASpace (Top Container records).
I could see this working in the tool because a user would be selecting a box size (which is what AbIDs are based on), and additionally they could add the location as well. there could potentially be more than one location added per collection. I'm attaching a spreadsheet of container profiles and locations if that helps to think this through. profiles-locations-repos.xlsx
assigned
by Eliot Jordan at 2020-10-02 14:47:49.assigned
by Eliot Jordan at 2020-10-02 16:08:32.closed
by Trey Pendragon at 2020-10-02 16:49:34.referenced
by Trey Pendragon at 2020-10-02 16:49:34.merged
by Trey Pendragon at 2020-10-02 16:49:34.closed
by Trey Pendragon at 2020-10-02 16:49:34.head_ref_deleted
by Trey Pendragon at 2020-10-02 16:49:38.renamed
by Eliot Jordan at 2020-10-02 14:53:49.assigned
by Eliot Jordan at 2020-10-02 15:18:37.closed
by Trey Pendragon at 2020-10-02 16:50:54.head_ref_force_pushed
by Eliot Jordan at 2020-10-02 15:28:09.referenced
by Trey Pendragon at 2020-10-02 16:50:54.merged
by Trey Pendragon at 2020-10-02 16:50:54.closed
by Trey Pendragon at 2020-10-02 16:50:55.head_ref_deleted
by Trey Pendragon at 2020-10-02 16:50:58.deployed
by Trey Pendragon at 2020-10-02 15:22:53.assigned
by Eliot Jordan at 2020-10-02 17:21:27.closed
by Trey Pendragon at 2020-10-02 22:45:34.referenced
by Trey Pendragon at 2020-10-02 22:45:33.merged
by Trey Pendragon at 2020-10-02 22:45:33.closed
by Trey Pendragon at 2020-10-02 22:45:34.head_ref_deleted
by Trey Pendragon at 2020-10-02 22:45:37.referenced
by Kevin Reiss at 2020-10-02 16:40:57.merged
by Kevin Reiss at 2020-10-02 16:40:58.closed
by Kevin Reiss at 2020-10-02 16:40:58.head_ref_deleted
by Kevin Reiss at 2020-10-02 16:41:01.duplicate of #841
closed
by None at 2020-10-02 18:54:33.Error Message to Patron: "You no longer have an active account and may not make digitization requests."


A smart bulb is an internet-capable LED light bulb that allows lighting to be customized, scheduled and controlled remotely. Smart bulbs are among the most immediately successful offerings in the growing category of home automation and Internet of Things (IoT) products.
With the integration of Wi-Fi, Bluetooth, ZigBee or a proprietary connection for a home automation systems, smart bulbs can be controlled through a mobile app or a home/building automation hub and individual bulbs can be programmed to change output in a specific manner. The bulb's internet connectivity makes it possible for vendors to use edge computing and equip smart bulbs with additional features like built-in cameras, built-in speakers and presence-sensing capability. Many types of smart bulbs enable the home or building manager to control brightness as well as RBG color.


Voluntary and open membership
Pur’N’Kleen is a voluntary organization, open to all persons able to use its services and willing
to accept the responsibilities of membership, without gender, social, racial, political, or
religious discrimination.
Democratic member control
Pur’N’Kleen is a democratic organization controlled by its members, who actively participate in
setting policies and decision making. In Pur’N’Kleen, members have a right and obligation to
participate in the decision making that affects them.
Member economic participation
Members contribute equitably to, and democratically control, the capital of Pur’N’Kleen. All members
gain or lose together. No single member benefits at the expense of other members.
Autonomy and independence
Pur’N’Kleen is an autonomous self-help organization that is controlled by its members.
Education, training, and information
Pur’N’Kleen will keep its members informed and provide education and training for its members,
elected representatives, managers, and employees so they can contribute effectively to the
development of Pur’N’Kleen.
Concern for community
While focusing on member’s needs, Pur’N’Kleen works for the sustainable development of their
communities through policies accepted by its members.


We work with different sectors of society to discover a "resource" in the discarded plastic bags.
Read MoreWe offer conferences and workshops to high-schools, associations, and any other institution interested in the excessive use of plastic and in responsible consumption.
Read MoreOur products are crocheted using as raw material plastic bags that commonly end up in the trash.
Read More


@*
* Copyright 2021 HM Revenue & Customs
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*@
@import helpers.templates.{payeErrorSummary, payeInput}
@import models.api.{CompanyDetails => CompanyDetailsAPI}
@import uk.gov.hmrc.play.views.html.{helpers => govHelpers}
@(detailsForm: Form[CompanyDetailsAPI])(implicit request: Request[_], messages: Messages)
@payeErrorSummary(
Messages("app.common.errorSummaryLabel"), detailsForm
)


About friendly
PyCon Lightning Talk - May 14, 2021
André Roberge
See PyCon's Education Summit
<Aside>
What's new in Python 3.10
?
Improved tracebacks!
Thanks to many people, but mostly Pablo Galindo Salgado.
May 8:
PEP 657
Include Fine Grained Error Locations in Tracebacks
Traceback ...
print(x[42][1][2][3][4])
^^^^^^^^^^^^^^
TypeError: 'NoneType' object is not subscriptable
</Aside>
What is friendly
?
Library providing help with tracebacks.
why()
where()
Python 3.6+
what()
SyntaxError: invalid syntax
www()
Python 3.10:
NameError, AttributeError
Python 3.10: Jupyter
# terminal, VS Code, etc.
from friendly import ...
# Special cases
from friendly.idle import ...
from friendly.mu import ...
from friendly.ipython import ...
from friendly.jupyter import ...
If you need help with tracebacks
> python -m pip install friendly
> python -m friendly
Friendly Console version ...
>>>


Second Test
One must compliment Team India for its victory over Bangladesh at Kolkata (‘Sport’ page, “Kohli and Ishant pile on Bangladesh’s misery”, November 24. While speedsters Ishant Sharma and Umesh Yadav bowled their hearts out to share the spoils, skipper Virat Kohli was all grace, poise and character as he let his willow do all the talking. His 41 tons across all formats puts him in an elite league along with Australia’s Ricky Ponting. The iconic batsman’s appetite for runs is terrific.
N.J. Ravi Chander,
Bengaluru


DesignDesk, based out of Mumbai (India), designs and builds exhibition stands. The website is a showcase of their work of 1200+ exhibitions for some of the biggest names, at expos held in India and abroad.
Custom design solutions for exhibitions, revamp of office spaces and much more.