Many Body Wavefunctions
Contents
Reading: (Baym, 1969).
Bosons and Fermions
An $N$ particle quantum system is described by a wavefunction of $N$ arguments $\Psi(\br_1,\ldots, \br_N)$. The starting point of many body quantum mechanics is that:
Systems of indistinguishable particles are described by totally symmetric or totally antisymmetric wavefunctions.
Just to be clear, totally symmetric means the wavefunction is unchanged by exchanging any two coordinates, whereas totally antisymmetric means that it changes sign.
A good fraction of this course is devoted to exploring the ramifications of this fact. Perhaps we should therefore give a very quick summary of why it appears to be true.
The first question is: what are indistinguishable particles?  Indistinguishable particles are those described by Hamiltonians that are invariant under permuting the particle’s labels. Thus the sum of single particle Hamiltonians
[did you remember that $\hbar=1$?] describes indistinguishable particles while
does not, on account of the masses being all different. Any time we have a symmetry operation that commutes with the Hamiltonian, the eigenstates of that symmetry are preserved by time evolution with that Hamiltonian. Thus a symmetric potential $V(x)=V(-x)$ commutes with the parity operation $x\to -x$, so the eigenstates of this operation – the even and odd wavefunctions – are preserved by time evolution.
The Hamiltonian of indistinguishable particles commutes with every operator of particle exchange, defined by
These operators satisfy $P_{ij}^2=\mathbb{1}$, so their eigenvalues are $\pm 1$, corresponding to states that are either symmetric or antisymmetric under exchange. The only simultaneous eigenstates of all particle exchange operations (note that different exchanges don’t commute if they involve the same particle) are the totally symmetric and antisymmetric wavefunctions. Thus these properties are preserved by time evolution. It’s always been this way.
We classify particles into symmetric bosons and antisymmetric fermions, named for Bose and Fermi respectively (the whimsical terminology is Dirac’s). The distinction works equally well for composite particles, provide we ignore the internal degrees of freedom and discuss only the center of mass coordinate.
All matter in the universe is made up of fermions: electrons, quarks, etc., but you can easily convince yourself that an even number of fermions make a composite boson (e.g. a $^4$He atom with two electrons, two neutrons and two protons) and an odd number make a composite fermion ($^3$He has one fewer neutron, which in turn is made up of 3 quarks).
Two Particles
A pair of particles is described by a wavefunction $\Psi(\mathbf{x},\mathbf{y})$. If we are dealing with distinguishable particles, the wavefunction of a pair of particles in states $\ket{\varphi_1}$ and $\ket{\varphi_2}$ would be
Accounting for indistinguishability, we have either
with the upper sign for bosons and the lower for fermions (The $1/\sqrt{2}$ yields a normalized wavefunction if $\varphi_{1,2}(\br)$ are orthonormal.). Note in particular that when $\varphi_1=\varphi_2$ the fermion wavefunction vanishes. This illustrates the Pauli exclusion principle, that no two identical fermions can be in the same quantum state. There is no such restriction for bosons.
Classically, if you had a function $P_{1}(\br_1)$ describing the probability density of finding particle $1$ at position $\br_1$, and the corresponding quantity for an independent particle $2$, you would have no hesitation in concluding that the joint distribution is
This also follows from taking the square modulus of $\eqref{quantum_statistics_ProductWavefunction}$. The results implied by the wavefunction $\eqref{quantum_statistics_sym}$ is
In particular, $P_{12}(\br,\br) = 0$ for fermions, and $P_{12}(\br,\br) = 2P_1(\br)P_2(\br)$ for bosons. The first result is natural from the standpoint of the exclusion principle, while the second is perhaps more surprising. This shows that, because probabilities arise from the squares of amplitudes, identical particles in quantum mechanics are never truly independent.
Four possible outcomes after the passage of two bosons through a beam splitter.
One dramatic illustration of this deviation from our classical intuition is provided by the Hong–Ou–Mandel effect in quantum optics. In simplified terms, we imagine wavepackets describing two photons (bosons) approaching a 50:50 beam splitter from either side. Because of the unitarity of scattering, the two photons end up in orthogonal states. For example,
Product States
The Hamiltonian of a system of $N$ identical noninteracting particles is a sum of $N$ identical single particle Hamiltonians, that is, with each term acting on a different particle coordinate
where $m$ is the particle mass, and $V(\mathbf{r_{i}})$ is a potential experienced by the particles. Let’s denote the eigenstates of the single particle Hamiltonian by ${\varphi_{\alpha}(\mathbf{r})}$, and the corresponding eigenenergies by ${E_{\alpha}}$, where $\alpha$ is a shorthand for whatever quantum numbers are used to label the states. A set of labels ${\alpha_{i}}$ $i=1,2,\ldots N$ tells us the state of each of the particles. Thus we can write an eigenstate of $N$ distinguishable particles with energy $E=\sum_{i=1}^{N}E_{\alpha_{i}}$ as
(We will frequently switch between the wavefunction $\varphi(\mathbf{x})$ and bra-ket notation $\ket{\varphi}$. In the latter notation the product wavefunction in $\eqref{quantum_statistics_ProductWavefunction}$ is written $\ket{\varphi_{1}}\ket{\varphi_{2}}$)
Such states are called product states. A general state will be expressed as a superposition of product states: they are special states which provide a frequently convenient basis.
As we’ve just discussed, however, we should really be dealing with a totally symmetric or totally antisymmetric wavefunction, depending on whether our identical particles are bosons or fermions. To write these down we introduce the operators of symmetrization and antisymmetrization
The sums are over all $N!$ permutations of $N$ objects, $P$ denotes the corresponding permutation operator, and $\sgn(P)$ is the signature of the permutation, equal to $+1$ for permutations involving an even number of exchanges, and $-1$ for an odd number. This allows us to write the totally symmetric and totally antisymmetric versions of $\eqref{quantum_statistics_disting}$ as
The normalization factors yield normalized wavefunctions if the single particle state $\ket{\varphi_\alpha}$ are orthonormal (as the eigenstates of the single particle Hamiltonian are).
The normalization factor in the boson case involves the occupation numbers ${N_{\alpha}}$ giving the number of particles in state $\alpha$. In the fermion case each $N_{\alpha}$ is either $0$ or $1$ so the prefactor simplifies. Since the order of the $\alpha$ indices is irrelevant in the boson case, and amounts only to a sign in the fermion case, states based on a given set of single particle states are more efficiently labeled by the occupation numbers. In terms of these numbers the total energy is
A more formal way of putting things is as follows. We first consider the space spanned by states of the form \eqref{quantum_statistics_disting}. Then we introduce the operators $\mathcal{S}$ and $\mathcal{A}$, noting that $\mathcal{S}^{2}=\mathcal{S}$ and $\mathcal{A}^{2}=\mathcal{A}$. In other words, there’s no point symmetrizing or antisymmetrizing more than once (we say that the operators are idempotent). Any eigenvalue of one of these operators is therefore either one or zero. The states with $\mathcal{S}=1$ are the symmetric states, and those with $\mathcal{A}=1$ are antisymmetric. You can easily convince yourself that if a state has one of $\mathcal{S}$ or $\mathcal{A}$ equal to one, the other is zero. This defines symmetric and antisymmetric subspaces, consisting of the admissible boson and fermion wavefunctions.
Note that the fermion wavefunction takes the form of a Slater determinant (though it appears first in (Dirac, 1926)).
The vanishing of a determinant when two rows or two columns are identical means that the wavefunction is zero if two particle coordinates coincide ($\br_{i}=\br_{j}$), or if two particles occupy the same state ($\alpha_{i}=\alpha_{j}$).
The 1D Fermi Gas
Let’s consider perhaps the simplest many particle system one can think of: noninteracting particles on a ring. If the ring has circumference $L$, the single particle eigenstates are
with $k_n=\frac{2\pi n}{L}$, $n\in\mathbb{Z}$. The corresponding energies are $E_{n}=\frac{k_n^2}{2m}$.
Ground State
Let’s find the $N$ particle ground state. For bosons every particle is in the state $\ket{\varphi_{0}}$ with zero energy: $N_{0}=N$. Thus
That was easy! The fermion case is harder.
Since the occupation of each level is at most one, the lowest energy is obtained by filling each level with one particle, starting at the bottom. If we have an odd number of particles, this means filling the levels with $n=-(N-1)/2, -(N-3)/2,\ldots, -1, 0, 1 \ldots (N-1)/2$ (for an even number of particles we have to decide whether to put the last particle at $n=\pm N/2$). Introducing the complex variables
the Slater determinant \eqref{quantum_statistics_slater} becomes
Let’s evaluate this complicated looking expression in a simple case. With three particles we have
The vanishing of the wavefunction when $x_{i}=x_{j}$ is consistent with the Pauli principle. You should check that additionally it is periodic and totally antisymmetric.
\eqref{3particle} generalizes for any (odd) $N$ so that the ground state Slater determinant \eqref{quantum_statistics_1ddet} is proportional to
Let’s take the opportunity to introduce some terminology. The wavevector of the last fermion added is called the Fermi wavevector and denoted $k_\text{F}$. In this case $k_\text{F}=\frac{(N-1)\pi}{L}$. Its energy $E_{F}=\frac{k_\text{F}^{2}}{2m}$ is the Fermi energy.
Density; Density Matrix; Pair Distribution
Having a many particle wave function is one thing, but what to do with it? Bear in mind that \eqref{quantum_statistics_1dFermiGS} is just about the simplest fermion state you can imagine, but it’s not immediately clear what it is telling us.
$\left|\Psi(x_1,\ldots,x_N)\right|^2$ is the probability distribution of the positions of the particles. If we were able to take a photograph of the positions of the particles at an instant in time, this would correspond to taking a sample from the probability distribution. In terms of the complex variables $z_j$, it would look something like this:
A sample from the probability distribution $\left|\Psi(z_1,\ldots,z_N)\right|^2$ for 50 particles (top) compared with a Poisson (uncorrelated) sample (bottom).
Since $\left|\Psi(x_1,\ldots,x_N)\right|^2$ is the probability distribution of the positions of the particles, we can use it to find the marginal probability distributions for any subset of the particles. Of course, since the particles are identical, it doesn’t matter which ones we choose, just the number.
The one particle distribution is related to the average density of particles, given by
Note that although I use the symbol $\rho$, density is always going to be number density (not the mass density).
Normalization of the wavefunction then implies
In a translationally invariant system like the fermion gas on a ring we expect the average density to be constant.
We can regard \eqref{ave_density} as an expectation of a density operator
so that $\rho_1 = \bra{\Psi}\rho\ket{\Psi}$.
We can also consider the density matrix of a single particle. Recall that the density matrix $\varrho$ describes a mixed state of a quantum system, and is the appropriate description when the quantum state is not known. $\varrho$ is a positive definite hermitian operator satisfying $\tr \varrho =1$. Its spectral resolution
can be thought of as a statistical mixture of different quantum states $\ket{\varphi_\alpha}$ with probabilities $p_\alpha$.
One natural way in which density matrices arise from pure states is as follows. The Hilbert space of a composite system consists of a tensor product of two or more components $\mathcal{H}_{AB} = \mathcal{H}_A \otimes \mathcal{H}_B$. Starting from the density matrix corresponding to a pure state, we can obtain a density matrix for the component $A$ alone by ‘tracing out’ the $B$ subsystem.
The probability for system $A$ to be in state $\ket{\psi}\in \mathcal{H}_A$ is
Applied to our many body states, the same logic leads us to define the single particle density matrix as
Note that $g(x,x) = \rho_1(x)$.
We can also consider marginal probability distribution of a pair of particles, and define the pair distribution function
The prefactor is to account for all pairs of particles.
A natural question:
Almost. Looking back at \eqref{many_densityop}, we see that the product of two density operators will contain terms involving the same particle, which are absent from $\rho_2(x_1,x_2)$.
Impenetrable Bose Gas
There’s a bit more mileage in the 1D Fermi gas yet. Consider the following Hamiltonian, which we’ll study in more detail in Lecture 15
The second term represents an interaction between pairs of particles. Of course, this model is rather special, as (1) it’s 1D and (2) the interaction potential is a $\delta$-function. Nevertheless, it represents a huge step up in difficulty from the noninteracting examples we’ve discussed so far. At least, it does for bosons. For fermions, the wavefunctions vanish at coincident points, and so the interaction has no effect at all!
For bosons, it happens that the Hamiltonian can still be solved exactly. For now, however, we’ll concern ourselves only with the limit of infinite interaction: $c\to \infty$, sometimes called the impenetrable limit. In this case, the eigenenergies coincide with those of the free fermion problem, and the eigenstates are just the modulus of the corresponding fermion eigenstate.
Just like that, we’ve solved our first interacting many body system (and with infinite coupling, no less)!
Thus the ground state on the ring has the form
This mapping is quite powerful, and allows us to calculate any observable of the impenetrable Bose gas in terms of free fermions as long as that observable is insensitive to taking the modulus of the wavefunction. Thus the average density $\rho_1(x)$ and pair distribution $\rho_2(x_1,x_2)$ of the previous section can be found in this way, but the single particle density matrix $g(x,y)$ cannot.
This means that the momentum distribution is not given by \eqref{many_Nk}. Finding $g(x,y)$ for the impenetrable Bose gas is in fact really hard. We’ll see in a later lecture how to obtain some of its important features.
References
- Baym, G. (1969). Lectures on quantum mechanics. WA Benjamin New York.
- Dirac, P. A. M. (1926). On the theory of quantum mechanics. Proceedings of the Royal Society of London. Series A, Containing Papers of a Mathematical and Physical Character, 661–677.


Special thanks to our friends at zillow.com for providing reliable information for our users
Uh-oh, not a match.
The Zillow search results don't return a record for that exact address. You can still view the neighborhoods in the area and other details, there are no real estate metrics for this address, however.
Uh-oh, not enough info.
We don't have enough information to provide any data for you, please provide additional detail.


*{{courseName}}*
Instructor: {{instructorfName}} {{instructorlName}}
Course Description
{{description}}
Be able to build ANY website you want.
Craft a portfolio of websites to apply for junior developer jobs.
Build fully-fledged websites and web apps for your startup or business.
Work as a freelance web developer.
Master backend development with Node
Master frontend development with React
Learn the latest frameworks and technologies, including Javascript ES6, Bootstrap 4, MongoDB.
Be able to build ANY website you want.
Craft a portfolio of websites to apply for junior developer jobs.
Build fully-fledged websites and web apps for your startup or business.
Work as a freelance web developer.
Master backend development with Node
Master frontend development with React
Learn the latest frameworks and technologies, including Javascript ES6, Bootstrap 4, MongoDB.


§157-26 Records of licensees. The board of agriculture may require licensees to keep such records and information as it deems necessary for the proper enforcement of this chapter. [L 1967, c 260, §17; HRS §157-26]


Using Titanium Desktop with Ruby
-
Using Ruby with Titanium Desktop
(NOTE: These Programming Guides only pertain to both Titanium Desktop 1.1 or earlier as well as 1.2.0.RC1 and more recent.)
You may also clone the Documentation-Examples repo on githuh and look at the TLMT example.
This example shows how to call language modules for PHP, Python and Ruby.
git://github.com/appcelerator/Documentation-Examples.git
The Titanium Desktop SDK includes a Ruby module, which allows developers to run Ruby code from within their applications. Here's a quick demonstration of what this means:
Titanium Desktop 1.2.0.RC1 SDKs and more recent.
The following is how Ruby would be include from the index.html file:

<title>Titanium Language Module Tester</title>

Welcome to the Titanium Language Module Tester

The following is the ruby.rb file include in the HTML file above.
def my_ruby_function(l)
n = 0
l.each { |i| n+=i }
return n
end
Titanium Desktop SDKs 1.1.0 and earlier.

The Ruby module currently uses the following version of Ruby depending on your platform. While this is
a good rule of thumb, the versions can and will change between specific SDKs, so always check for the
version being used in the specific SDK you are using.
-
Windows: Ruby 1.8
-
OS X (Leopard): Ruby 1.8
-
OS X (Snow Leopard): Ruby 1.9
-
Linux (all distributions): Ruby 1.8
It's recommended that you write your code to be compatible with Ruby 1.8.
-
Including Ruby in your application
-
There are a few ways to include Ruby scripts on your Titanium pages. As demonstrated above, you can include a script tag with type="text/ruby." If you have a Ruby source file that you want to include you can also do this:
Titanium Desktop SDKs 1.1.0 and earlier.

-
The Kroll / Ruby Bridge
-
Kroll is the underlying object and communication system in Titanium. It has its own object system, including its own spectrum of types. Whenever you call Ruby from JavaScript or JavaScript from Ruby, your data will be flowing through Kroll.
-
Numbers
Since all JavaScript Numeric variables are floating-point, when they are passed into Ruby, they will be converted into Ruby Floats. JavaScript Numerics are converted by value rather than converted by reference.
-
Titanium Desktop SDKs 1.1.0 and earlier.

One important result of Kroll using floating point numbers is that if you send a Ruby Integer into JavaScript and then back into Ruby, that number will always be a Ruby Float.
Booleans
JavaScript Booleans are also converted by value directly to a Ruby bool and vice-versa.
Null, undefined and nil
JavaScript null and undefined are always converted to Ruby nil. Ruby nil is always converted to JavaScript null.
 This means that if you change a JavaScript object in Ruby, that change will be reflected in the original object. When dealing with objects that flow from one language context to another, it suffices to think of them as the same object.
Titanium Desktop SDKs 1.1.0 and earlier.

Ruby objects work the same way when moving to JavaScript. Here's an example:
Titanium Desktop SDKs 1.1.0 and earlier.

Ruby objects have different ways to set properties. When setting a property on a Ruby object, Kroll will try to set that property in a few different ways. Take this code for example:
Titanium Desktop SDKs 1.1.0 and earlier.

When the JavaScript code attempts to set the foo property on globalObject, it will attempt several things on the Ruby object:
1. Setting the <tt>foo</tt> property via the <tt>foo=</tt> if that method exists.
2. <tt>foo=</tt> does not exist. Set the <tt>foo</tt> property via <tt>globalObject.instance_variable_set()</tt>
Kroll follows a similar pattern when searching for a property.
Titanium Desktop SDKs 1.1.0 and earlier.

1. Return the result of <tt>globalobject.foo()</tt> if it exists.
2. If <tt>@foo</tt> is defined in globalObject, return that.
3. Otherwise call <tt>globalObject.method_missing</tt>
-
Return a value if method_missing succeeds.
-
If a NoMethodError is thrown, return undefined.
-
Otherwise throw the exception <tt>globalObject.method_missing</tt> returned.
-
Hashes
-
Ruby hashes can be passed to JavaScript. They will be Objects whose properties are just hash accesses. For instance:

-
Arrays
JavaScript arrays in are wrapped in an Array-like object in Ruby. Be aware that although this object operates much like a Ruby Array, it is not a true Ruby Array. You should be able to use it just like a Array in most situations though.
-
Titanium Desktop SDKs 1.1.0 and earlier.

Passing Ruby Arrays to JavaScript will result in a true JavaScript Array. That means that the JavaScript object which wraps the Ruby object will have an Array prototype and the full complement of JavaScript array methods.
Titanium Desktop SDKs 1.1.0 and earlier.

-
Exceptions
-
Exceptions that are thrown in either Ruby or JavaScript will be converted using the same rules as normal variables when bubbling up into different languages. This means that if an exception is thrown in Ruby, you should be able to catch it in JavaScript and vice-versa.


title: Deploying the Crate Distributed Database Using Mesos and Marathon
author: Christian Haudum
description: Use Mesosphere's Marathon to easily deploy a Crate database cluster with Docker containers.
created: 2015/03/06 12:00:00
post_name: crate-with-mesosphere
status: publish
post_type: post
tags: docker, mesosphere, marathon
category: news, developernews
_This is a guest post originally published on Mesosphere's Blog on Feb 25, 2015._
Editor's Note: This guest post is written by Christian Haudum of Crate. Crate is a venture-funded startup that has built a container-native distributed database for large and real-time datasets. We're proud of the thriving ecosystem of third-party datacenter services being built around Mesos and the Mesosphere DCOS, and we wanted to give Crate an opportunity to share their new product with our audience.
Crate is a distributed database designed to work seamlessly in containerized environments. Due to its shared-nothing architecture it's a perfect fit as a persistence layer for clustered applications. Crate gives you the resilient database cluster with automatic sharding and replication without forcing you to give up the simplicity of SQL as a query language. You will also benefit from the capability of automatic healing if nodes should fail.
Using Mesosphere's Marathon to manage Crate containers makes it easy to deploy a containerized database cluster very efficiently and allocate database resources quickly depending on your demands, and therefore simplifies the management of elastic applications.
In this post we'll quickly to through the necessary steps to set up a scalable Crate cluster. We'll skip over some of the basics, so you should take a look at the Mesosphere documentation and the Crate Docker installation guide first if you aren't familiar with those.
Ok, let's start!
##Initial Mesos/Marathon Setup
We'll set up a Mesos cluster on Google Compute Engine with one single master and three slaves following the [Mesosphere Install Guide](http://mesosphere.com/docs/getting-started/datacenter/install/).
```
> gcloud compute instances create mesos-master \
--image centos-7 --zone us-central1-b --network mesos
```
```
> gcloud compute instances create mesos-slave-{1..3} \
--image centos-7 --zone us-central1-b --network mesos
```
> The `mesos` network has firewall rules applied that prevent un-authorized access to the ports that will be exposed to the pubic otherwise! Crate uses the ports `4200` (HTTP) and `4300` (internal transport) per default.
###Node Configuration
Instances within the same network are able to see each other by their hostname, meaning that you don't need to know the internal IP for the Zookeeper configuration, but only the hostname of the master that we chose when we started the node.
```
zk://mesos-master:2181/mesos
```
As [documented](http://mesosphere.com/docs/tutorials/launch-docker-container-on-mesosphere/), we also need to change the configuration of the `mesos-slave` service, more specifically the containerizers and the registration timeout.
```
$ echo 'docker,mesos' > /etc/mesos-slave/containerizers
$ echo '10mins' > /etc/mesos-slave/executor_registration_timeout
$ echo 'ports(*):[31000-31099, 31101-32000, 4200-4399]' > /etc/mesos-slave/resources
```
If the `mesos-slave` service refuses to start, you'd probably need to delete the temporary slave recovery file.
```sh
$ sudo rm -f /tmp/mesos/meta/slaves/latest
```
It is recommended to set the timeout to `10mins`, because the first docker run needs to pull the images and that may take a while ;)
Now that everything is ready, we can actually start with the Crate specific setup.
## Launching Crate with Marathon
Launching a Crate cluster with Marathon is very simple. All you need to do is defining a few settings in a Marathon configuration file.
We're going to look at possible cluster setups, one with unicast discovery and a second one with multicast discovery (utilizing Weave). These are currently the 2 possible ways how multiple nodes of Crate can find each other and form a cluster.
In both cases Mesos-DNS is a neat way to easily let your application "find" the Crate nodes by a human readable domain name.
### Using Unicast Discovery
The easiest way to get started with a Crate cluster using Marathon is to use unicast discovery.
On the `mesos-master` instance create a Marathon config file and call it for example `CrateUnicast.json`. This will be submitted to Marathon later to start the Crate instances.
```
{
"id": "crate-mesos-unicast",
"container": {
"type": "DOCKER",
"docker": {
"image": "crate/crate:0.47.3",
"privileged": true,
"network": "HOST",
"parameters": []
},
"volumes": [
{
"containerPath": "/tmp",
"hostPath": "/tmp",
"mode": "RO"
},
{
"containerPath": "/data",
"hostPath": "/data/crate",
"mode": "RW"
}
]
},
"instances": 3,
"cpus": 1,
"mem": 2014,
"uris": [],
"cmd": "crate -Des.cluster.name=mesos-unicast -Des.zen.discovery.minimum_master_nodes=2",
"env": {
"CRATE_HOSTS": "mesos-slave-1:4300,mesos-slave-2:4300,mesos-slave-3:4300",
"CRATE_HEAP_SIZE": "1024m"
},
"constraints": [
[
"hostname",
"UNIQUE"
]
],
"ports": []
}
```
We set the key `network` for the container to `HOST`, so Mesos automatically binds Crate's internal ports (`4200`/`4300`) to the host network.
Additionally we specify the environment variables `CRATE_HOSTS` (all available slaves at port 4300) and `CRATE_HEAP_SIZE` (half of the host's available memory).
The constraint `["hostname", "UNIQUE"]` guarantees that only one single Crate container is running on a slave.
In total we'll have `3` nodes. In order to have an unambiguous quorum we need to provide the `minimum_master_nodes` in the run command (`cmd` key) and set it to `2` (=`num_nodes/2+1`, see [Multi Node Setup](https://crate.io/docs/en/latest/best_practice/multi_node_setup.html)).
For the volumes, we can either create a re-usable data directory - in our case `/data/crate` - on the root disk (e.g. if you have an SSD root disk) or mount a separate disk. Then just adopt the path accordingly.
Now let's submit this config file to Marathon, which is running on port `8080`.
```
$ curl -s -XPOST http://localhost:8080/v2/apps<EMAIL_ADDRESS>-H "Content-Type: application/json"
```
In the Marathon web UI (which runs on port `8080`) you can see that the app is popping up. Once the instances are running, we can verify the cluster with a curl command:
```
$ curl -s -XPOST mesos-slave-1:4200/_sql?pretty -d '{
"stmt":"select name, hostname from sys.nodes"
}'
```
The cluster is of course reachable on every single slave:
```
$ curl -s -XPOST mesos-slave-2:4200/_sql?pretty -d '{
"stmt":"select name, hostname from sys.nodes"
}'
$ curl -s -XPOST mesos-slave-3:4200/_sql?pretty -d '{
"stmt":"select name, hostname from sys.nodes"
}'
```
So far, it seems that there haven't been that many advantages over a conventional docker deployment of Crate - except the overhead of setting up the Mesos cluster. However, [Marathon is much more](https://mesosphere.github.io/marathon/) than just a deployment tool, it is a "cluster-wide init and control system for services or Docker containers". That means, that you can easily start, stop and manage application clusters by just writing the app configuration and submitting it to Marathon.
To test Marathon's capability to retain the application cluster contraints that we've specified in the `CrateUnicast.json` file, you can manually stop a docker container and watch the web UI restarting the lost instance. If you have access to the Crate Admin UI (`MESOS_SLAVE_IP:4200/admin/`) you should import a few thousand tweets using the Get Started Tutorial and set the number of replicas for the `tweets` table to `1-2` first. Then you're able to see Crate's "self-healing" capacity.
*Note: It is also possible to scale your Crate cluster using the Marathon web UI, but you need to be careful, because the `minimum_master_nodes` [setting](https://crate.io/docs/en/latest/search.html?q=minimum_master_nodes) is applied to each newly created Crate node.
### Using Multicast Discovery
We've already written a blog post on how to utilize Weave for multicast discovery for Crate.
This time we'll go a little further and adopt the concept of automatic IP assignment of Docker containers laid out in the great blog post [Adventures with Weave and Docker](http://sttts.github.io/docker/weave/mesos/2015/01/22/weave.html) by Stefan Schimanski.
The idea is that Weave creates a virtual network and each host defines its own subnet, in which docker can assign IPs automatically to containers.
So we're going to install Weave on the slaves, create a bridge and tell the docker daemon to use a fixed IP range for its containers.
```
mesos-master
bridge cidr <IP_ADDRESS>/16
container cidr <IP_ADDRESS>/24
mesos-slave-1
bridge cidr <IP_ADDRESS>/16
container cidr <IP_ADDRESS>/24
mesos-slave-2
bridge cidr <IP_ADDRESS>/16
container cidr <IP_ADDRESS>/24
mesos-slave-3
bridge cidr <IP_ADDRESS>/16
container cidr <IP_ADDRESS>/24
```
This will allow us to run 255 Mesos slaves and 255 containers on each slave. That should be enough for now, but if you want you can use wider IP ranges.
In order to do multicast discovery we need to first install Weave on the Mesos master and all the nodes:
```
$ sudo yum install bridge-utils -y
$ sudo curl --silent --location --output /usr/sbin/weave https://github.com/zettio/weave/releases/download/latest_release/weave
$ sudo chmod +x /usr/sbin/weave
```
If you haven't installed Docker on `mesos-master` you'd need to do that now, because Weave depends on it. Additionally, we need to tell the Docker to used a fixed IP range for the containers. This can be achieved by adding `--bridge` and `--fixed-cidr` to the launch options in `/etc/sysconfig/docker`.
```
# /etc/sysconfig/docker
OPTIONS=--selinux-enabled -H fd:// --bridge=weave --fixed-cidr=<IP_ADDRESS>/24
# DOCKER_TMPDIR=/var/tmp
```
Create the weave bridge and expose it to the host:
```
$ sudo weave create-bridge
$ sudo weave expose <IP_ADDRESS>/16
```
(Re)start the Docker service so it uses the new launch options and start the weave network:
```
$ sudo service docker restart
$ sudo weave launch
```
For the slaves it is basically the same procedure, you can use this bash script:
```
#!/bin/bash -x
sudo yum install bridge-utils -y
sudo curl --silent --location --output /usr/sbin/weave https://github.com/zettio/weave/releases/download/latest_release/weave
sudo chmod +x /usr/sbin/weave
# $1 .. unique id of the slave (1..254)
HOST_ID="$1"
BRIDGE_CIDR="192.168.0.${HOST_ID}/16"
NETWORK_CIDR="192.168.${HOST_ID}.0/24"
echo "# /etc/sysconfig/docker
# Modify these options if you want to change the way the docker daemon runs
OPTIONS=--selinux-enabled -H fd:// --bridge=weave --fixed-cidr=${NETWORK_CIDR}" | sudo tee /etc/sysconfig/docker > /dev/null
sudo weave create-bridge
sudo weave expose ${BRIDGE_CIDR}
sudo service docker restart
# we connect to the already existing network on mesos-master
sudo weave launch mesos-master
```
Execute the script with the slave id, `1` for `mesos-slave-1`, and so on, on each node.
```
$ ./install-weave-bridge.sh 1
```
Verify the network status:
```
$ sudo weave status
weave router 0.9.0
Encryption off
Our name is 7a:13:3b:07:3d:61
Sniffing traffic on &{8 65535 ethwe ba:11:3a:61:d6:31 up|broadcast|multicast}
MACs:
02:42:c0:a8:03:01 -> 7a:ff:6c:20:7f:78 (2015-02-12 17:30:46.714657091 +0000 UTC)
ba:11:3a:61:d6:31 -> 7a:13:3b:07:3d:61 (2015-02-12 17:22:53.45073163 +0000 UTC)
02:42:c0:a8:ff:01 -> 7a:13:3b:07:3d:61 (2015-02-12 17:22:59.07080863 +0000 UTC)
7a:13:3b:07:3d:61 -> 7a:13:3b:07:3d:61 (2015-02-12 17:30:08.585423533 +0000 UTC)
02:42:c0:a8:01:01 -> 7a:74:e5:fe:bf:fe (2015-02-12 17:30:08.759828667 +0000 UTC)
02:42:c0:a8:02:01 -> 7a:0c:69:e3:13:7c (2015-02-12 17:30:08.585252474 +0000 UTC)
Peers:
Peer 7a:0c:69:e3:13:7c (v2) (UID<PHONE_NUMBER>423039471)
-> 7a:13:3b:07:3d:61 [<IP_ADDRESS>:6783]
Peer 7a:ff:6c:20:7f:78 (v2) (UID<PHONE_NUMBER>024318277)
-> 7a:13:3b:07:3d:61 [<IP_ADDRESS>:6783]
Peer 7a:13:3b:07:3d:61 (v6) (UID<PHONE_NUMBER>665720550)
-> 7a:74:e5:fe:bf:fe [<IP_ADDRESS>:40679]
-> 7a:0c:69:e3:13:7c [<IP_ADDRESS>:49763]
-> 7a:ff:6c:20:7f:78 [<IP_ADDRESS>:48296]
Peer 7a:74:e5:fe:bf:fe (v2) (UID<PHONE_NUMBER>939719523)
-> 7a:13:3b:07:3d:61 [<IP_ADDRESS>:6783]
Routes:
unicast:
7a:13:3b:07:3d:61 -> 00:00:00:00:00:00
7a:74:e5:fe:bf:fe -> 7a:74:e5:fe:bf:fe
7a:0c:69:e3:13:7c -> 7a:0c:69:e3:13:7c
7a:ff:6c:20:7f:78 -> 7a:ff:6c:20:7f:78
broadcast:
7a:ff:6c:20:7f:78 -> [7a:74:e5:fe:bf:fe 7a:0c:69:e3:13:7c]
7a:13:3b:07:3d:61 -> [7a:74:e5:fe:bf:fe 7a:0c:69:e3:13:7c 7a:ff:6c:20:7f:78]
7a:74:e5:fe:bf:fe -> [7a:0c:69:e3:13:7c 7a:ff:6c:20:7f:78]
7a:0c:69:e3:13:7c -> [7a:74:e5:fe:bf:fe 7a:ff:6c:20:7f:78]
Reconnects:
```
Now we can launch the cluster with multicast discovery. The app specification (make a new file names `CrateWeave.json`) becomes even simpler, because the hosts for unicast discovery do not need to be specified.
```
{
"id": "crate-mesos-weave",
"container": {
"type": "DOCKER",
"docker": {
"image": "crate/crate:0.47.3",
"privileged": true,
"network": "BRIDGE",
"portMappings": [
{ "containerPort": 4200, "hostPort": 4200, "protocol": "tcp" },
{ "containerPort": 4300, "hostPort": 4300, "protocol": "tcp" }
],
"parameters": [
]
}
},
"instances": 3,
"cpus": 0.2,
"mem": 2014,
"uris": [],
"cmd": "crate -Des.cluster.name=mesos-weave -Des.network.publish_host=_local_",
"env": {
"CRATE_HEAP_SIZE": "1024m"
},
"constraints": [
["hostname", "UNIQUE"]
],
"ports": []
}
```
Note that in this case we define a port mapping and using the BRIDGE network. We also need to tell the crate binary to use `_local_` for the `publish_host` which will be resolved to the local IP address of the container.
Then submit it to Marathon:
```
$ curl -s -XPOST http://localhost:8080/v2/apps<EMAIL_ADDRESS>-H "Content-Type: application/json"
```
The nodes of the Crate cluster will discover each through multicast which is enabled by the Weave network.
And again, the cluster can be verified:
```
$ curl -s -XPOST mesos-slave-1:4200/_sql?pretty -d '{"stmt":"select id, name, hostname from sys.nodes"}'
{
"cols" : [ "id", "name", "hostname" ],
"duration" : 12,
"rows" : [ [ "e3r05rFVTaebqdTIidoLCQ", "Lupo", "b60ad27ae040" ], [ "lXVvEVcYS5GqHY6Y1R7omA", "Valinor", "f3f1e64f843e" ], [ "Yn1M2L1BS9KDMFvBZVw4tA", "Gardener", "5d169e51b2c4" ] ],
"rowcount" : 3
}
```
### Using Mesos DNS to Find Nodes
> Mesos-DNS supports service discovery in Apache Mesos clusters. It allows applications and services running on Mesos to find each other through the domain name system (DNS), similarly to how services discover each other throughout the Internet.
Unfortunately Crate does not have node discovery via DNS (yet), but Mesos-DNS really makes it easy to find the individual nodes of the existing Crate cluster. This is especially useful when connecting with a client application.
The Mesos-DNS service is written in Go, which needs to be installed first. We will install the service on `mesos-master`, but it could be also installed on any Mesos node, or even on a dedicated host. It also requires git, if not already installed.
### Configure The Master
Mesosphere again provides a very good [installation guide](http://mesosphere.github.io/mesos-dns/docs/), so we can skip it here and proceed with the configuration file.
```
{
"masters": ["mesos-master:5050"],
"refreshSeconds": 30,
"ttl": 60,
"domain": "crate",
"port": 53,
"resolvers": ["...", "<IP_ADDRESS>"],
"timeout": 5,
"email": "root.mesos-dns.crate"
}
```
Since we have only a single Mesos master and the DNS serive is running on the same host, you could also set `masters` to `["localhost:5050"]`. If you have more masters you'd need to extend the list accordingly. You should also add the nameserver IPs from `/etc/resolv.conf` and append them before Google's `<IP_ADDRESS>` nameserver in the `resolvers` attribute.
Now start the service in the background:
```
$ sudo mesos-dns -config=config.json &
```
For debugging purposes it makes sense to start the process in the foreground first and use the `-v=true` option to obtains debugging information:
```
$ sudo mesos-dns -config=config.json -v=true
```
### Configure The Slaves
Add `nameserver ` as first line to `/etc/resolv.conf` so it looks similar like this:
```
# Generated by NetworkManager
nameserver <IP_ADDRESS>
domain c.crate-gce.internal.
search c.crate-gce.internal.<PHONE_NUMBER>137.google.internal. google.internal.
nameserver <IP_ADDRESS>
nameserver <IP_ADDRESS>
```
Mesos tasks will be exposed via DNS using the `task.framework.domain` notation. Our task is named `crate-mesos-unicast`, the framework we're using is `marathon` and as DNS domain we specified `crate`, so the full qualified name is `crate-mesos-unicast.marathon.crate`.
It can be tested using `dig` (requires `bind-utils` to be installed):
```
$ dig crate-mesos-unicast.marathon.crate A | grep 'IN A'
crate-mesos-unicast.marathon.crate. 60 IN A <IP_ADDRESS>
crate-mesos-unicast.marathon.crate. 60 IN A <IP_ADDRESS>
crate-mesos-unicast.marathon.crate. 60 IN A <IP_ADDRESS>
```
We can now access the Crate cluster from any slave host with its full qualified domain name.
```
$ curl -s -XPOST crate-mesos.marathon.crate:4200/_sql?pretty -d '{
"stmt":"select name, hostname from sys.nodes"
}'
```
```
{
"cols" : [ "name", "hostname" ],
"duration" : 307,
"rows" : [ [ "Cadaver", "mesos-slave-1" ], [ "Svarog", "mesos-slave-2" ], [ "Valkyrie", "mesos-slave-3" ] ],
"rowcount" : 3
}
```
### Summary
Marathon makes it really easy to deploy a resilient Crate cluster thanks to it's capability to retain the application cluster constraints by automatically healing any failures. Together with Crate's replication it creates a very durable database backend for large distributed applications.
In addition to that, Mesos-DNS allows applications and clients to easily find and connect to nodes of the Crate cluster.
**Update** (March 3rd, 2015):
In a previous version of the post we used `weave expose ` to expose the bridge IP to the host. However, this issue on Github points out that `weave expose` can cause routing loops, because it "will add additional iptables masquerading rules which can cause the tunneled data packets to be routed again via the `weave` interface." - Thanks Ilya for letting us know!
Create the weave bridge and expose it to the host assign the IP address directly to the network device:
```
$ sudo weave create-bridge
$ sudo ip addr add dev weave <IP_ADDRESS>/16
```
For the slaves it is basically the same procedure, you can use this bash script:
```
#!/bin/bash -x
sudo yum install bridge-utils -y
sudo curl --silent --location --output /usr/sbin/weave https://github.com/zettio/weave/releases/download/latest_release/weave
sudo chmod +x /usr/sbin/weave
# $1 .. unique id of the slave (1..254)
HOST_ID="$1"
BRIDGE_CIDR="192.168.0.${HOST_ID}/16"
NETWORK_CIDR="192.168.${HOST_ID}.0/24"
echo "# /etc/sysconfig/docker
# Modify these options if you want to change the way the docker daemon runs
OPTIONS=--selinux-enabled -H fd:// --bridge=weave --fixed-cidr=${NETWORK_CIDR}" | sudo tee /etc/sysconfig/docker > /dev/null
sudo weave create-bridge
sudo ip addr add dev weave ${BRIDGE_CIDR}
sudo service docker restart
# we connect to the already existing network on mesos-master
sudo weave launch mesos-master
```
^ change also the 4th to last line to reflect the update


We love to design products and brands and learn new things.
---
title: Vývojka
subtitle: Design studio
description: Vývojka is an innovation design studio based in Bratislava, Slovakia.
layout: default
published: true
group: index
lang: en
language: English
og-locale: en_US
og-image: vyvojka-essence-2by1-w2000.jpg
order: 1
---
We love to design products and brands and learn new things.
We are an innovation design studio based in Bratislava, Slovakia.
Companies hire us to define, ideate, prototype, produce, test, and validate products and brands.
We are proud to work for Eset, DZ Dražice, and Re pello.


Cohort month October 2015 - off-flows required to reach standard
Show/hide filters
{% include "latest/performance_filters.html" %}You searched: Coventry, Worcester > JSA > Cohort month October 2015
Previous standard
Next standard
| Sign offs required to reach standard | |||||||||
|---|---|---|---|---|---|---|---|---|---|
| Site | Claims opened | Claims closed | Achieved % | Into work % | JSA 13 | JSA 26 | JSA 39 | JSA 52 | |
| Coventry | 200 | 120 | 60 | 70 | 10 | 42 | 60 | 68 | |
| Worcester | 150 | 75 | 50 | 65 | 15 | 45 | 61 | 65 |


I used SQuirrelSQL at my workshop very frequently. It is a super useful open source program that can interact with your database (DB2, MySQL, SQLite..etc). To make SQLite to work with any type of database, all you need is the JDBC driver (since SQuirrelSQL is written in java) and setup the drivers correctly with the correct connection string.
In this tutorial, I will show you how to setup SQLite Driver in SQuirrelSQL. SQLite Driver is by default not in SQuirrelSQL.
Step 1: Downloading SQLite JDBC Driver
Your first step is to install SQLite JDBC connector. Go to this website to download the driver (see screen shot about which file to download)
Step 2: Copy and Paste SQLite JDBC jar file to SQuirrelSQL bin folder.
If you install SQuirrelSQL from scratch (without changing the program folder), the SQLite program folder will most likely appear in your C:drive > Program Files (x86) > SQuirrel-sql-[version]. Open the bin folder, and you will see a tonne of jar file. Copy and paste the SQLite JDBC jar file that you have just downloaded in this location.
Step 3: Adding SQLite JDBC Driver to SQuirrleSQL
Fire up the SQuirrelSQL program, and click on the driver menu (on your left side bar) and click the add button to add a new driver in SQuirrelSQL. Enter your driver name: “SQLite Driver”, the example URL: “jdbc:sqlite:SQLiteDatabaseFileLocation” and website URL: “https://bitbucket.org/xerial/sqlite-jdbc/overview”. After that, find the SQLite JDBC Jar file that you have just added to the bin folder. (see screenshot)
Step 4: Adding your SQLite database to SQuirrelSQL
To add your SQLite database to SQuirrelSQL, go to the aliases menu (on your left side bar) and click on the add button to add new alias. Enter a name for the alias and select the SQLite driver you have just added in Step 3. For the URL field, you first need to find out the file path of your SQLite database. In this example, my SQLite database resides in my desktop folder “C:\Users\euwernNew\Desktop\test” (Note: test is my SQLite database, I did not specify the file extension for my SQLite database in this example)
Replace the “SQLiteDatabaseFileLocation” string with the actual File location of your SQLite database. (see screenshot)
Click the “Test” button and click “connect” you do not need any username or password. A dialog box will show up indicating “connection successful”.
And that’s it, you have successfully open a SQLite database in SQuirrelSQL.
One more thing, I noticed that the default installation of SQuirrelSQL comes with very tiny font size. It is not very obvious on how to increase the font size of your SQL panel, To do so, Go to File > New Session Properties. Click on the “SQL tab” and scroll down to “SQL Entry Area” and set your font size. Have fun
Hi,
i tried to transfer your example to OSX. On OSX you have diifferent folders but the sqlite-jdbc.jar is found in the “Java Class Path”-window. In the other fileds i put the informatin according to Step 3. I then added “org.sqlite.JDBC” for the class name.
Squirrel then notifies:
Could not find class org.sqlite.JDBC in neither the Java class path nor the Extra class path of the SQLite Driver driver definition:
java.lang.ClassNotFoundException: org.sqlite.JDBC
Do you have any ideas?
Hi,
I don’t have a mac machine with me. Can you try clicking on the “extra class path” tab in the driver and then click the “Add” button to locate the jar file (where you downloaded from the website). Next, type in the same info as shown in Step 3 screen shot. (Name, Example URL, Website URL, Class Name). Let me know if it works
Hi,
thanks for your advice. I tried “extra class path” and added the folder with the jar.
Now it works:
Driver class org.sqlite.JDBC successfully registered for driver definition: SQLite Driver
Thank you!
For Website URl you should add: https://bitbucket.org/xerial/sqlite-jdbc/overview
The URL you mentioned in step 3 doesn’t work anymore.
Best regards, Bebass


--- title: Zbalermorna ---
Zbalermorna is a diacritic orthography for Lojban, created by la kmir. A couple diferent versions of the write-ups exist in the wild, and this page is an attempt to consolodate all of the information on Zbalermorna, and provide resources for fonts, IMEs, and other software.
The page itself is hosted on Github pages through Jack's fork of la kmir's official repo - most of the content here should be considered a unofficial, and while some feedback on the ideas proposed has been collected from la kmir, a lot of it is still actively being worked on.


UI/UX Resources
Softwares and Templates
Design Resources for Developers
Curated list of design and UI resources from software suggestions to web templates, CSS frameworks, UI libraries and much more.
Blush : Illustrations for Everyone
Create, mix, and customize illustrations made by artists around the world.
Blogs
Degreeless.design - Everything I Learned in Design School
A guide for budding UX, UI, Interaction designers. A collection of resources to help you start from the beginning and build up your skills.
The Disconnect between Students and the Design Industry
A blog by Sanjana Galgalikar, elaborating the struggles of breaking into the design industry.
UX Design Resource Collection
List of companies that have design teams and some interesting blogs.
47 Key Lessons for UI & UX Designers
A mega-list of critical knowledge for UI, UX, Interaction, and Product designers alike.
The Guide to Design : Why design, Why now?
A comprehensive collection of articles to get started with design now!
Design Schools
Digital Product School
Digital Product School is a full-time training program by UnternehmerTUM in Munich, Europe's biggest Entrepreneurship Center.
Online Product School - Students who Design
Students Who Design is easiest way to go from 0 to your first product design job. Take live, online classes and get 1:1 help whenever you need it. And the best part? It costs nothing.
Design Interview Resources
How Recruiters look at your Design Portfolio
Ever wonder how recruiters look at your design portfolio? 5 insights from design recruiters and managers


Please enter a number from 1-10 in the boxes to the left of the restaurant food pic
10 = That's my kind of food! 1 = Yuck!


Friends is an American television sitcom, created by David Crane and Marta Kauffman, which aired on NBC from September 22, 1994, to May 6, 2004, lasting ten seasons. The show revolves around six friends in their 20s and 30s who live in Manhattan, New York City. The series was produced by Bright/Kauffman/Crane Productions, in association with Warner Bros. Television. The original executive producers were Kevin S. Bright, Kauffman, and Crane.
Series creator David Crane wanted all six actors to be equally prominent, and the series was lauded as being "the first true 'ensemble' show. The cast members made efforts to keep the ensemble format and not allow one member to dominate; they entered themselves in the same acting categories for awards, opted for collective salary negotiations, and asked to appear together on magazine cover photos in the first season. The cast members also became best friends off-screen, so much so that recurring guest star Tom Selleck reported that he sometimes felt left out.
The cast remained good friends after the series run, most notably Cox and Aniston, with Aniston being godmother to Cox and David Arquette's daughter, Coco. In the official farewell commemorative book Friends 'Til the End, each separately acknowledged in interviews that the cast had become their family.
Although the producers thought of Friends as "only a TV show", psychologists investigated the cultural impact of Friends during the series's run. Aniston's hairstyle was nicknamed "The Rachel" and copied around the world.Joey's catchphrase, "How you doin'?", became a popular part of Western English slang, often used as a pick-up line or when greeting friends. The series also influenced the English language, according to a study by the University of Toronto that found that the characters used the emphasized word "so" to modify adjectives more often than any other intensifier. Although the preference had already made its way into the American vernacular, usage on the series may have accelerated the change. Chandler's habit of ending a sentence unfinished for sarcasm also influenced viewers' speech.
Filming took place at Warner Bros. Studios in Burbank, California. All ten seasons of Friends ranked within the top ten of the final television season ratings; it ultimately reached the number-one spot in its eighth season. The series finale aired on May 6, 2004, and was watched by around 52.5 million American viewers, making it the fifth most-watched series finale in television history, and the most-watched television episode of the 2000s.
Friends has also been credited in helping non-English speaking students to learn the language. A 2012 poll by Kaplan International English Colleges found that more than a quarter (26%) of its students cited the sitcom as the best show for helping them improve their English. Notable individuals who have also said that the sitcom helped them learn English include Liverpool F.C. manager Jürgen Klopp, BTS member RM and Belgian professional golfer Thomas Pieters.


Componentization of a UI-UX design to build the anfix 2.0 single-page web application with React.js (ECMAScript 6 version processed with Babel.js), Node.js, Compass, HTML5, Gulp, Webpack. Testing React.js components with mocha.js. Worked closely with UI & UX designers, backend engineers, product team... to create functional, reusable and scalable React.js components
Front-End / Web development for international clients through the freelance jobs website www.elance.com. PSD to HTML5 CSS3 jQuery - WordPress solutions, Presashop solutions and others CMS, server migrations, maintenance... etc.
Front-Ent development in a big project for the main spanish telecommunications company (Telefonica) using the latest technologies such as HTML5, CSS3, SASS, jQuery, Tortoise SVN... etc. I did quit because of the low salary according the living costs in Madrid.
Migration to a new server of a fully working installation of WordPress + Prestashop. Integrity testing, DNS change, and tweaking of the header of the Prestashop online shop.
Design and front-end development of two sections (Petitions y Crowdfunding) of a italian social network dedicated to pets and related companies such as veterinary clinics, trainers and specialty pet food stores.
Design and development of web technology, web development implementation, clients consultancy, formation.
Basic computer science lessons to unemployed people. Course Content: Office, Internet, email, creating and maintaining a blog, basic web design (HTML and CSS).
Basic computer science lessons to unemployed people. Course Content: Office, Internet, email, creating and maintaining a blog, basic web design (HTML and CSS).
Installation and config, theme design and development, maintenance. As photographer entusiast this is my platform to share and publish my photographies.
Installation, configuration, theme and logo design, creation of products, photography of products, payment integration and configuration, maintenance.
Installation, configuration, theme design and development, SEO, maintenance, more than 18.000 unique visitors per month.


Global error codes definitions. More...
Macros | |
| #define | NRFX_ERROR_BASE_NUM 0x0BAD0000 |
| #define | NRFX_ERROR_DRIVERS_BASE_NUM (NRFX_ERROR_BASE_NUM + 0x10000) |
Enumerations | |
| enum | nrfx_err_t { NRFX_SUCCESS = ( 0x0BAD0000 + 0), NRFX_ERROR_INTERNAL = ( 0x0BAD0000 + 1), NRFX_ERROR_NO_MEM = ( 0x0BAD0000 + 2), NRFX_ERROR_NOT_SUPPORTED = ( 0x0BAD0000 + 3), NRFX_ERROR_INVALID_PARAM = ( 0x0BAD0000 + 4), NRFX_ERROR_INVALID_STATE = ( 0x0BAD0000 + 5), NRFX_ERROR_INVALID_LENGTH = ( 0x0BAD0000 + 6), NRFX_ERROR_TIMEOUT = ( 0x0BAD0000 + 7), NRFX_ERROR_FORBIDDEN = ( 0x0BAD0000 + 8), NRFX_ERROR_NULL = ( 0x0BAD0000 + 9), NRFX_ERROR_INVALID_ADDR = ( 0x0BAD0000 + 10), NRFX_ERROR_BUSY = ( 0x0BAD0000 + 11), NRFX_ERROR_ALREADY_INITIALIZED = ( 0x0BAD0000 + 12), NRFX_ERROR_DRV_TWI_ERR_OVERRUN = ( ( 0x0BAD0000 + 0x10000) + 0), NRFX_ERROR_DRV_TWI_ERR_ANACK = ( ( 0x0BAD0000 + 0x10000) + 1), NRFX_ERROR_DRV_TWI_ERR_DNACK = ( ( 0x0BAD0000 + 0x10000) + 2) } |
| Enumerated type for error codes. More... | |
Global error codes definitions.
Copyright (c) 2017 - 2018, Nordic Semiconductor ASA
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
| enum nrfx_err_t |
Enumerated type for error codes.


Class Searcher
The searcher class provides all you need to query your ElasticSearch server.
Namespace: elasticsearch
License: http://opensource.org/licenses/MIT
Author: Paris Holley<EMAIL_ADDRESS>Version: 4.0.1
Located at Searcher.php
License: http://opensource.org/licenses/MIT
Author: Paris Holley<EMAIL_ADDRESS>Version: 4.0.1
Located at Searcher.php
public static
array
|
|
public static
|
#
_searchField( $fields, $type, $exclude, $search, $facets, & $musts, & $filters, & $scored, $numeric )
|


--- layout: default --- {% include core/social.html %} {{ page.title }} {{ content }} {% include core/footer.html %}


TagResolution
Namespace: Legivel
Nested types and modules
| Type | Description |
| GlobalTagSchema |
A schema for tags and tag-resolution functions |
| TagResolutionFunc |
Function signature that is to resolve the tag of a Node |
| TagResolutionInfo |
Info required for tag resolution |
| UnresolvedTagResolutionFunc |
Function signature that is to return a GlobalTag for an unresolved tag |
| Module | Description |
| Failsafe |
Failsafe schema: http://www.yaml.org/spec/1.2/spec.html#id2802346 |
| JSON |
Json schema: http://www.yaml.org/spec/1.2/spec.html#id2803231 |
| NonSpecific |
Non specific tags, "!", "?" and unresolved |
| SchemaUtils | |
| YamlCore |
Core Schema: http://www.yaml.org/spec/1.2/spec.html#id2804923 |
| YamlExtended |
'Extended' schema (not official name): http://yaml.org/type/ |


Ionic Creator
Prototype & Design
Visually build high-fidelity apps in minutes. Drag and drop UI components, add themes, animations, design files, and even custom code to create real, interactive Ionic mobile apps.
{% extends '_layouts/base.html' %} {% set id = 'products' %} {% set mixpanelEnabled = true %} {% set bodyController = "ProductsPageCtrl" %} {% block header_style %}transparent{% endblock %} {% block body_attributes %} data-spy="scroll" data-target="#platform-nav" data-offset="100" {% endblock %} {% block main %}
Spend more time on what matters. Ionic takes care of the rest, with a suite of powerful mobile development tools and services for apps of all shapes and sizes.
Give you and your team all the tools needed to quickly move from app ideation to app store, allowing you to easily transition between the critical phases of your mobile development lifecycle.
Ionic Creator allows every member of your team to participate in drag-and-drop prototyping, and exports real Ionic code to kick off your development.
Use the Ionic View app for live app testing and to get your app in the hands of clients, testers, or collaborators as quickly as you make changes.
Push hot code updates, content changes, A/B tests, and bug fixes in real time before and after your app is in the app stores, with Ionic Deploy.
Create native apps in the cloud with Ionic Package to get from code to app store with no platform dependencies or complicated build steps.
Visually build high-fidelity apps in minutes. Drag and drop UI components, add themes, animations, design files, and even custom code to create real, interactive Ionic mobile apps.
Ionic is the only mobile app stack that enables web developers apps for all major app stores and the mobile web with a single code base. And with Ionic’s Platform Continuity, your app looks and feels at home on every device.
The Ionic View app makes it easy to live preview, test, and distribute your apps directly on the device with co-workers, testers, and clients alike. Get better feedback, faster and more easily.
Ionic deploy is a lean development service that enables Ionic developers to push live app updates directly to users and testers in realtime. It works by acting as a central source of truth that developers can publish JS, HTML, and CSS changes to. Users and testers devices use the SDK to pull down the latest code changes.
This enables you to streamline your development lifecycle by quickly addressing bugs, adding features, and shipping changes painlessly without having to rebuild your binary or redistribute to the app store.
Turn your web assets into native SDKs for multiple platforms, in the cloud, from a single codebase. Leave configuration, compilation, and packaging to us, so you can focus on shipping.
Spend more time on what matters. Supercharge your Ionic development with a Professional account for your team.
CommunityFreeThe Ionic you know and love |
Professional
$1999/dev/yearSupercharge your team's workflow |
|
|---|---|---|
| Open Source Development | ||
| Ionic Framework | ||
| Ionic CLI | ||
|
Ionic Creator - Design & Prototyping
|
||
| Local Project Export | Trial (No Exporting) | |
| Native IPA/APK Export | - | |
|
Ionic View - Live Device Testing
|
||
| Tester Accounts | 2 | Unlimited |
| Private Projects | No (Publicly Visible) | |
| Multiple Deploy Channels | - | Unlimited |
|
Ionic Deploy - Realtime App Updating
|
||
| Deploy Limit | 5 Devices | Unlimited |
| Multiple Deploy Channels | - | Unlimited |
| Custom Split Testing Channels | - | Unlimited |
|
Ionic Package - Native Cloud Builds
|
||
| IPA & APK Builds | ||
| Custom Icon & Splashscreen | - | |
| Custom Plugins in Builds | - | |
| Get Started | Try the Beta! |


This class represents the rotate-and-shift transform which gives the location and orientation of a new frame F in a base (reference) frame B.
More...
|
| | Transform_ () |
| | Default constructor gives an identity transform. More...
|
| |
| | Transform_ (const Rotation_< P > &R, const Vec< 3, P > &p) |
| | Combine a rotation and a translation into a transform. More...
|
| |
| | Transform_ (const Rotation_< P > &R) |
| | Construct or default-convert a rotation into a transform containing that rotation and zero translation. More...
|
| |
| | Transform_ (const Vec< 3, P > &p) |
| | Construct or default-convert a translation (expressed as a Vec3) into a transform with that translation and a zero rotation. More...
|
| |
| Transform_ & | operator= (const InverseTransform_< P > &X) |
| | Assignment from InverseTransform. More...
|
| |
| template<int S> |
| Transform_ & | operator+= (const Vec< 3, P, S > &offset_B) |
| | Add an offset to the position vector in this Transform. More...
|
| |
| template<int S> |
| Transform_ & | operator-= (const Vec< 3, P, S > &offset_B) |
| | Subtract an offset from the position vector in this Transform. More...
|
| |
| Transform_ & | set (const Rotation_< P > &R, const Vec< 3, P > &p) |
| | Assign a new value to this transform, explicitly providing the rotation and translation separately. More...
|
| |
| Transform_ & | setToZero () |
| | By zero we mean "zero transform", i.e., an identity rotation and zero translation. More...
|
| |
| Transform_ & | setToNaN () |
| | This fills both the rotation and translation with NaNs. More...
|
| |
| const InverseTransform_< P > & | invert () const |
| | Return a read-only inverse of the current Transform_. More...
|
| |
| InverseTransform_< P > & | updInvert () |
| | Return a writable (lvalue) inverse of the current transform, simply by casting it to the InverseTransform_. More...
|
| |
| const InverseTransform_< P > & | operator~ () const |
| | Overload transpose operator to mean inversion. More...
|
| |
| InverseTransform_< P > & | operator~ () |
| | Overload transpose operator to mean inversion. More...
|
| |
| Transform_ | compose (const Transform_ &X_FY) const |
| | Compose the current transform (X_BF) with the given one. More...
|
| |
| Transform_ | compose (const InverseTransform_< P > &X_FY) const |
| | Compose the current transform (X_BF) with one that is supplied as an InverseTransform_ (typically as a result of applying the "~" operator to a transform). More...
|
| |
| Vec< 3, P > | xformFrameVecToBase (const Vec< 3, P > &vF) const |
| | Transform a vector expressed in our "F" frame to our "B" frame. More...
|
| |
| Vec< 3, P > | xformBaseVecToFrame (const Vec< 3, P > &vB) const |
| | Transform a vector expressed in our "B" frame to our "F" frame. More...
|
| |
| Vec< 3, P > | shiftFrameStationToBase (const Vec< 3, P > &sF) const |
| | Transform a point (station) measured from and expressed in our "F" frame to that same point but measured from and expressed in our "B" frame. More...
|
| |
| Vec< 3, P > | shiftBaseStationToFrame (const Vec< 3, P > &sB) const |
| | Transform a point (station) measured from and expressed in our "B" frame to that same point but measured from and expressed in our "F" frame. More...
|
| |
| const Rotation_< P > & | R () const |
| | Return a read-only reference to the contained rotation R_BF. More...
|
| |
| Rotation_< P > & | updR () |
| | Return a writable (lvalue) reference to the contained rotation R_BF. More...
|
| |
| const Rotation_< P >::ColType & | x () const |
| | Return a read-only reference to the x direction (unit vector) of the F frame, expressed in the B frame. More...
|
| |
| const Rotation_< P >::ColType & | y () const |
| | Return a read-only reference to the y direction (unit vector) of the F frame, expressed in the B frame. More...
|
| |
| const Rotation_< P >::ColType & | z () const |
| | Return a read-only reference to the z direction (unit vector) of the F frame, expressed in the B frame. More...
|
| |
| const InverseRotation_< P > & | RInv () const |
| | Return a read-only reference to the inverse (transpose) of our contained rotation, that is R_FB. More...
|
| |
| InverseRotation_< P > & | updRInv () |
| | Return a writable (lvalue) reference to the inverse (transpose) of our contained rotation, that is R_FB. More...
|
| |
| const Vec< 3, P > & | p () const |
| | Return a read-only reference to our translation vector p_BF. More...
|
| |
| Vec< 3, P > & | updP () |
| | Return a writable (lvalue) reference to our translation vector p_BF. More...
|
| |
| Transform_< P > & | setP (const Vec< 3, P > &p) |
| | Assign a new value to our translation vector. More...
|
| |
| Vec< 3, P > | pInv () const |
| | Calculate the inverse of the translation vector in this transform. More...
|
| |
| Transform_< P > & | setPInv (const Vec< 3, P > &p_FB) |
| | Assign a value to the inverse of our translation vector. More...
|
| |
| const Mat< 3, 4, P > & | asMat34 () const |
| | Recast this transform as a read-only 3x4 matrix. More...
|
| |
| Mat< 3, 4, P > | toMat34 () const |
| | Less efficient version of asMat34(); copies into return variable. More...
|
| |
| Mat< 4, 4, P > | toMat44 () const |
| | Return the equivalent 4x4 transformation matrix. More...
|
| |
| const Vec< 3, P > & | T () const |
| |
| Vec< 3, P > & | updT () |
| |
|
(Note that these are not member functions.)
|
| template<class P , int S> |
| Vec< 3, P > | operator* (const Transform_< P > &X_BF, const Vec< 3, P, S > &s_F) |
| | If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector. More...
|
| |
| template<class P , int S> |
| Transform_< P > | operator+ (const Transform_< P > &X_BF, const Vec< 3, P, S > &offset_B) |
| | Adding a 3-vector to a Transform produces a new shifted transform. More...
|
| |
| template<class P , int S> |
| Transform_< P > | operator+ (const Vec< 3, P, S > &offset_B, const Transform_< P > &X_BF) |
| | Adding a 3-vector to a Transform produces a new shifted transform. More...
|
| |
| template<class P , int S> |
| Transform_< P > | operator- (const Transform_< P > &X_BF, const Vec< 3, P, S > &offset_B) |
| | Subtracting a 3-vector from a Transform produces a new shifted transform. More...
|
| |
| template<class P , int S> |
| Vec< 4, P > | operator* (const Transform_< P > &X_BF, const Vec< 4, P, S > &a_F) |
| | If we multiply a transform or inverse transform by an augmented 4-vector, we use the 4th element to decide how to treat it. More...
|
| |
| template<class P , class E > |
| Vector_< E > | operator* (const Transform_< P > &X, const VectorBase< E > &v) |
| | Multiplying a matrix or vector by a Transform_. More...
|
| |
| template<class P > |
| Transform_< P > | operator* (const Transform_< P > &X1, const Transform_< P > &X2) |
| | Composition of transforms. More...
|
| |
| template<class P > |
| bool | operator== (const Transform_< P > &X1, const Transform_< P > &X2) |
| | Comparison operators return true only if the two transforms are bit identical; that's not too useful. More...
|
| |
| template<class P > |
| std::ostream & | operator<< (std::ostream &, const Transform_< P > &) |
| | Generate formatted output of a Transform to an output stream. More...
|
| |
template<class P>
class SimTK::Transform_< P >
This class represents the rotate-and-shift transform which gives the location and orientation of a new frame F in a base (reference) frame B.
A frame is an orthogonal, right-handed set of three axes, and an origin point. A transform X from frame B to F consists of 3 perpendicular unit vectors defining F's axes as viewed from B (that is, as expressed in the basis formed by B's axes), and a vector from B's origin point Bo to F's origin point Fo. Note that the meaning of "B" comes from the context in which the transform is used. We use the phrase "frame F is in frame B" to describe the above relationship, that is, "in" means both measured from and expressed in.
The axis vectors constitute a Rotation_. They are ordered 1-2-3 or x-y-z as you prefer, with z = x X y, making a right-handed set. These axes are arranged as columns of a 3x3 rotation matrix R_BF = [ x y z ] which is a direction cosine (rotation) matrix useful for conversions between frame B and F. (The columns of R_BF are F's coordinate axes, expressed in B.) For example, given a vector vF expressed in the F frame, that same vector re-expressed in B is given by vB = R_BF*vF. F's origin point OF is stored as the translation vector p_BF=(Fo-Bo) and expressed in B.
Transform is designed to behave as much as possible like the computer graphics 4x4 affine transform X which would be arranged like this:
[ | ]
X = [ R | p ] R is a 3x3 orthogonal rotation matrix
[.......|...] p is a 3x1 translation vector
[ 0 0 0 1 ]
These can be composed directly by matrix multiplication, but more importantly they have a particularly simple inverse:
-1 [ | ]
X = [ ~R | p* ] ~R is R transpose, p* = ~R(-p).
[.......|....]
[ 0 0 0 1 ]
This inverse is so simple that we compute it simply by defining another type, InverseTransform_, which is identical to Transform_ in memory but behaves as though it contains the inverse. That way we invert just by changing point of view (recasting) rather than computing.
This is a "POD" (plain old data) class with a well-defined memory layout on which a client of this class may depend: There are exactly 4 consecutive, packed 3-vectors in the order x,y,z,p. That is, this class is equivalent to an array of 12 Reals with the order x1,x2,x3,y1,y2,y3,z1,z2,z3,p1,p2,p3. It is expressly allowed to reinterpret Transform objects in any appropriate manner that depends on this memory layout.


CKEditor Samples
Basic Samples
- Replace textarea elements by class name
- Automatic replacement of all textarea elements of a given class with a CKEditor instance.
- Replace textarea elements by code
- Replacement of textarea elements with CKEditor instances by using a JavaScript call.
Basic Customization
- User Interface languages
- Changing CKEditor User Interface language and adding a drop-down list that lets the user choose the UI language.
Plugins
- AutoGrow pluginNew!
- Using the AutoGrowplugin in order to make the editor grow to fit the size of its content.
- Output for BBCode
- Configuring CKEditor to produce BBCode tags instead of HTML.
- Developer Tools plugin
- Using the Developer Tools plugin to display information about dialog window UI elements to allow for easier customization.
- Stylesheet Parser plugin
- Using the <b>Stylesheet Parser</b> plugin to fill the Styles drop-down list based on the CSS classes available in the document stylesheet.


We are open from 6am to 7pm
If you want more information about us and our locations
Please click More details from the bar above
If you want more information about us and our locations
Please click More details from the bar above
Lorem ipsum dolor sit amet consectetur adipisicing elit. Reprehenderit hic repudiandae recusandae eligendi. Nemo saepe quos error minus. Alias tenetur aliquid molestias? Aut a quas quos aliquid cumque maxime in!


mysqli_stmt::bind_result mysqli_stmt_bind_result (PHP 5, PHP 7) mysqli_stmt::bind_result -- mysqli_stmt_bind_result — Binds variables to a prepared statement for result storage 说明 面向对象风格 bool mysqli_stmt::bind_result ( mixed &$var1 [, mixed &$... ] ) 过程化风格 bool mysqli_stmt_bind_result ( mysqli_stmt $stmt , mixed &$var1 [, mixed &$... ] ) Binds columns in the result set to variables. When mysqli_stmt_fetch() is called to fetch data, the MySQL client/server protocol places the data for the bound columns into the specified variables var1, .... Note: Note that all columns must be bound after mysqli_stmt_execute() and prior to calling mysqli_stmt_fetch(). Depending on column types bound variables can silently change to the corresponding PHP type. A column can be bound or rebound at any time, even after a result set has been partially retrieved. The new binding takes effect the next time mysqli_stmt_fetch() is called. 参数 stmt 仅以过程化样式：由 mysqli_stmt_init() 返回的 statement 标识。 var1 The variable to be bound. 返回值 成功时返回 TRUE，或者在失败时返回 FALSE。 范例 Example #1 面向对象风格 prepare( "SELECT Code, Name FROM Country ORDER BY Name LIMIT 5")) { $stmt->execute(); /* bind variables to prepared statement */ $stmt->bind_result($col1, $col2); /* fetch values */ while ($stmt->fetch()) { printf("%s %s\n", $col1, $col2); } /* close statement */ $stmt->close(); } /* close connection */ $mysqli->close(); ?> Example #2 过程化风格 以上例程会输出： AFG Afghanistan ALB Albania DZA Algeria ASM American Samoa AND Andorra 参见 • mysqli_stmt_get_result() - Gets a result set from a prepared statement • mysqli_stmt_bind_param() - Binds variables to a prepared statement as parameters • mysqli_stmt_execute() - Executes a prepared Query • mysqli_stmt_fetch() - Fetch results from a prepared statement into the bound variables • mysqli_prepare() - Prepare an SQL statement for execution • mysqli_stmt_prepare() - Prepare an SQL statement for execution • mysqli_stmt_init() - 初始化一条语句并返回一个用于mysqli_stmt_prepare(调用) 的对象 • mysqli_stmt_errno() - Returns the error code for the most recent statement call • mysqli_stmt_error() - Returns a string description for last statement error User Contributed Notes 17 notes =============================================================================== I wrote a function that fetches all rows from a result set - either normal or prepared. store_result(); $variables = array(); $data = array(); $meta = $result->result_metadata(); while($field = $meta->fetch_field()) $variables[] = &$data[$field->name]; // pass by reference call_user_func_array(array($result, 'bind_result'), $variables); $i=0; while($result->fetch()) { $array[$i] = array(); foreach($data as $k=>$v) $array[$i][$k] = $v; $i++; // don't know why, but when I tried $array[] = $data, I got the same one result in all rows } } elseif($result instanceof mysqli_result) { while($row = $result->fetch_assoc()) $array[] = $row; } return $array; } ?> Simply call it passing a result set or executed statement and you'll get all rows fetched. =============================================================================== lot of people don't like how bind_result works with prepared statements! it requires you to pass long list of parameters which will be loaded with column value when the function being called. To solve this, i used call_user_func_array function and result_metadata functions. which make easy and automatically returns an array of all columns results stored in an array with column names. please don't forget to change setting variables with your own credentials: prepare("SELECT * FROM sample WHERE t2 LIKE ?")) { $tt2 = '%'; $stmt->bind_param("s", $tt2); $stmt->execute(); $meta = $stmt->result_metadata(); while ($field = $meta->fetch_field()) { $params[] = &$row[$field->name]; } call_user_func_array(array($stmt, 'bind_result'), $params); while ($stmt->fetch()) { foreach($row as $key => $val) { $c[$key] = $val; } $result[] = $c; } $stmt->close(); } $mysqli->close(); print_r($result); ?> =============================================================================== If you select LOBs use the following order of execution or you risk mysqli allocating more memory that actually used 1)prepare() 2)execute() 3)store_result() 4)bind_result() If you skip 3) or exchange 3) and 4) then mysqli will allocate memory for the maximal length of the column which is 255 for tinyblob, 64k for blob(still ok), 16MByte for MEDIUMBLOB - quite a lot and 4G for LONGBLOB (good if you have so much memory). Queries which use this order a bit slower when there is a LOB but this is the price of not having memory exhaustion in seconds. =============================================================================== A note to people to want to return an array of results - that is, an array of all the results from the query, not just one at a time. fetch()) { $results[] = $byref_array_for_fields; } ?> This will NOT work. $results will have a bunch of arrays, but each one will have a reference to $byref. PHP is optimizing performance here: you aren't so much copying the $byref array into $results as you are *adding* it. That means $results will have a bunch of $byrefs - the same array repeated multiple times. (So what you see is that $results is all duplicates of the last item from the query.) hamidhossain (01-Sep-2008) shows how to get around that: inside the loop that fetches results you also have to loop through the list of fields, copying them as you go. In effect, copying everything individually. Personally, I'd rather use some kind of function that effectively duplicates an array than write my own code. Many of the built-in array functions don't work, apparently using references rather than copies, but a combination of array_map and create_function does. fetch()) { // array_map will preserve keys when done here and this way $results[] = array_map($copy, $byref_array_for_fields); } ?> All these problems would go away if they just implemented a fetch_assoc or even fetch_array for prepared statements... =============================================================================== If I have a longtext field in the result, the whole page will go blank, without giving me any errors what so ever. This is because PHP _crashes_. I've spent an entire morning figuring this out. Apparently, if you have longtext present, you HAVE to call store_result before using bind_result. http://bugs.php.net/bug.php?id=47928 =============================================================================== Just wanted to make sure that all were aware of get_result for those needing the result in array format. In the code sample, after execute(), perform a get_result() like this: execute(); /* instead of bind_result: */ $result = $stmt->get_result(); /* now you can fetch the results into an array - NICE */ while ($myrow = $result->fetch_assoc()) { printf("%s %s\n", $myrow['Code'], $myrow['Name']); } ?> This is much nicer when you have a dozen or more fields coming back from your query. Hope this helps. Also, as noted in the comments for get_result, it requires mysqlnd. =============================================================================== bind_ result can also be used to return an array of variables from a function, This took me a long time to figure out, so I would like to share this. conn->prepare($query)) { $stmt->execute(); $stmt->bind_result($updates[0],$updates[1],$updates[2],$updates[3]); $i=0; while($stmt->fetch()){ $i++; $name='t'.$i; $$name = array($updates[0],$updates[1],$updates[2],$updates[3]); } return array($t1,$t2,$t3,$t4,$t5,); $stmt->close(); } } ?> =============================================================================== For those of you trying to bind rows into array, prepare('SELECT id, name, mail, phone, FROM contacts'); $stmt->execute(); $stmt->store_result(); $stmt->bind_result($arr['id'], $arr['name'], $arr['mail'], $arr['phone']); while ($stmt->fetch()) { $outArr[] = $arr; } $stmt->close(); return $outArr; ?> this will give you all the rows you asked for except that they would all be the same as the first one because of some gremlins in the background code (i've heard that PHP is trying to save memory here). But this one works: prepare('SELECT id, name, mail, phone, FROM contacts'); $stmt->execute(); $stmt->store_result(); $stmt->bind_result($a,$b,$c,$d); while ($stmt->fetch()) { $outArr[] = ['id' => $a, 'name' => $b, 'mail' => $c, 'phone' => $d]; } $stmt->close(); return $outArr; ?> Just don't use arrays to bind results :) =============================================================================== for people who doesn't have the mysqlInd driver or for some reason just can't use the stmt->get_result, I've made this function which allows you to "mimic" the mysqli_result::fetch_assoc: function fetchAssocStatement($stmt) { if($stmt->num_rows>0) { $result = array(); $md = $stmt->result_metadata(); $params = array(); while($field = $md->fetch_field()) { $params[] = &$result[$field->name]; } call_user_func_array(array($stmt, 'bind_result'), $params); $stmt->fetch(); return $result; } return null; } you can use it in a while sentence to fetch and return an assoc array from the statement (as long as the statement is open): usage: $statement = $mysqli->prepare($query)); $statement.execute(); while($rowAssocArray = fetchAssocStatement($statement)) { //do something } $statement.close(); hope this helps. =============================================================================== Took some cool code from here and made a little class for those object oriented kind of guys used like this: execute(); $stmt->store_result(); //custom class :D bind to Statement Result mambo jambo! $sr = new Statement_Result($stmt); $stmt->fetch(); printf("ID: %d\n", $sr->Get('id') ); ///////////////////////////////// class Statement_Result { private $_bindVarsArray = array(); private $_results = array(); public function __construct(&$stmt) { $meta = $stmt->result_metadata(); while ($columnName = $meta->fetch_field()) $this->_bindVarsArray[] = &$this->_results[$columnName->name]; call_user_func_array(array($stmt, 'bind_result'), $this->_bindVarsArray ); $meta->close(); } public function Get_Array() { return $this->_results; } public function Get($column_name) { return $this->_results[$column_name]; } } ?> =============================================================================== According to the above documentation: "Depending on column types bound variables can silently change to the corresponding PHP type. " if you specify a field as int (tinyint, mediumint, etc.) with zerofill property, it will be converted (silently) to PHP integer (erasing the leading zeros). In order to keep those leading zeros, one solution is to specify the field as decimal. Note that this only happens when using prepared statements and not when executing the query directly. =============================================================================== If done properly, 'call_user_func_array()' works to bind variables to a result of multiple columns including BLOB columns. EXAMPLE: Here's the complete example. WARNING: When using 'prepare' to prepare a statement to retrieve LOBs the method order matters. Also, method 'store_result()' must be called and be called in correct order. Failure to observe this causes PHP/MySQLi to crash or return an erroneous value. The proper procedure order is: prepare -> execute -> store_result -> bind -> fetch execute -> store_result -> bind -> fetch $stmt = $mysqli->prepare("SELECT $select_set FROM `$table`") ; $stmt->execute(); $stmt->store_result(); $data = array() ; // Array that accepts the data. $params = array() ; // Parameter array passed to 'bind_result()' foreach($column as $col_name) { // Assign the fetched value to the variable '$data[$name]' $params[] =& $data[$col_name] ; } $res = call_user_func_array(array($stmt, "bind_result"), $params) ; if(! $res) { echo "bind_result() failed: " . $mysqli->error . "\n" ; } else { $res = $stmt->fetch() ; if($res) { echo "
" . htmlentities(print_r($data, true)) . "\n" ; } else { echo ((false !== $res) ? "End of data" : $stmt->error) . "\n" ; } } $stmt->close() ; $mysqli->close() ; exit ; ?> The above example should output: Array ( [fidentity] => 24 [fvarchar] => the rain in spain [fdate] => 2010-07-31 [ftinyblob] => GIF89a...(more BLOB data) ) =============================================================================== Although inspired by an earlier post, this method could be added to any of your database objects. It's an object oriented implementation of an earlier post. The method returns an array with objects representing a row. Each property represents a column and its value. result_metadata(); $fields = $metadata->fetch_fields(); for (;;) { $pointers = array(); $row = new stdClass(); $pointers[] = $stmt; foreach ($fields as $field) { $fieldname = $field->name; $pointers[] = &$row->$fieldname; } call_user_func_array(mysqli_stmt_bind_result, $pointers); if (!$stmt->fetch()) break; $result[] = $row; } $metadata->free(); return $result; } ?> =============================================================================== To clarify for anyone having problems with arrays, PHP will automatically pass arrays as references, cloning the array if needed in the event of setting or unsetting a part of it, changing a referenced variable does not trigger cloning. This is done for efficiency, to clone an array containing this information you may either use a foreach loop, or set/unset a key. Techniques like array_values will also work provided you don't mind losing your keys. =============================================================================== I've created these functions which will act like mysqli_fetch_array() and mysqli_fetch_object() but work with bound results. stmt); $count = 1; //start the count from 1. First value has to be a reference to stmt. $fieldnames[0] = &$this->stmt; $obj = new stdClass; while ($field = mysqli_fetch_field($data)) { $fn = $field->name; //get all the feild names $fieldnames[$count] = &$obj->$fn; //load the fieldnames into an object.. $count++; } call_user_func_array(mysqli_stmt_bind_result, $fieldnames); mysqli_stmt_fetch($this->stmt); return $obj; } function fetch_array() { $data = mysqli_stmt_result_metadata($this->stmt); $count = 1; //start the count from 1. First value has to be a reference to the stmt. because bind_param requires the link to $stmt as the first param. $fieldnames[0] = &$this->stmt; while ($field = mysqli_fetch_field($data)) { $fieldnames[$count] = &$array[$field->name]; //load the fieldnames into an array. $count++; } call_user_func_array(mysqli_stmt_bind_result, $fieldnames); mysqli_stmt_fetch($this->stmt); return $array; } ?> Hope this helps some people, I was puzzled by this for a while. =============================================================================== A potential problem exists in binding result parameters from a prepared statement which reference large datatypes like mediumblobs. One of our database tables contains a table of binary image data. Our largest image in this table is around 50Kb, but even so the column is typed as a mediumblob to allow for files larger than 64Kb. I spent a frustrating hour trying to figure out why mysqli_stmt_bind_result choked while trying to allocate 16MB of memory for what should have been at most a 50Kb result, until I realized the function is checking the column type first to find out how big a result _might_ be retrieved, and attempting to allocate that much memory to contain it. My solution was to use a more basic mysqli_result() query. Another option might have been to retype the image data column as blob (64Kb limit). =============================================================================== I discovered this one by accident; mysqli_stmt_bind_result overwrites an *existing* session variable of the same name (but doesn't create them). In other words, mysqli_stmt_bind_result($stmt, $col1, $col2); will overwrite session variables $_SESSION['col1'] and $_SESSION['col2'] if they exist, but will not create them if they don't.


Pisth
Pisth is an SSH and SFTP client.
Use Pisth to upload, view and edit files in your SSH server.
Why use Pisth:
• Pisth is totally free (but there are ad banners).
• You can manage files in your SSH server and use the Shell in the same app.
• You can edit text files and code with colored syntax.
• The Shell supports colors and real time output and input, so you can use text editors such as nano, vim, etc.
• The Shell supports Bluetooth keyboard including arrows and ctrl keys but excluding function keys.
Screenshots
Creating a pull request
Documentation
If you want to contribute to the documentation, don’t edit the docs
directory, but just document the code, the page will be generated by me with Jazzy (but if you want, you can generate the page after commenting).
Style
Marks
Put -
in marks.
For protocools or super classes in marks, remove modules prefix, put spaces between words, a capital at start, and no capitals after.
For example, use: // MARK: - The name of protocool
instead of // MARK: - PTTheNameOfProtocool
Documentation
Put fullstops after documented comments.
Tabs
Use 4 spaces tabs.
Acknowledgements
See licenses here.


LOLOL
What is better than a blue screen of death?
huh, a customizable blue screen of laugh??
If you'd like to contact Tommy, you can find him on:
Twitter
/
Facebook
Moreover, turn the script on, it is required for awesomeness.


Mocha
A lightweight, multi-threaded, client-server library for Java
Mocha is a lightweight, multi-threaded client-server library for Java. It enables the quick creation of multi-client, multi-port TCP and UDP clients and servers with minimal overhead. Mocha allows you to quickly set up and run TCP and UDP servers as well as TCP, UDP, and WebSocket clients. By using Mocha, you can avoid dealing with low-level networking technologies and protocols, instead concentrating on business logic of your server.
Contents
Download and import
You can easily import Mocha in your project using Maven or Gradle:
Maven:
<dependency> <groupId>com.raylabz</groupId> <artifactId>mocha</artifactId> <version>1.0.5</version> </dependency>
Gradle:
implementation 'com.raylabz:mocha:1.0.5'
Alternatively, you can download Mocha as a .jar:
Server guide
The server guide will guide you through the process of creating a server and assigning TCP and UDP port handlers to handle traffic.
Click here to view the server guideClient guide
The client guide will guide you through the process of creating TCP, UDP, and WebSocket clients.
Click here to view the client guideDocumentation
License
Mocha is released under the Apache 2.0 license.
Source code
You can find the source code at the project's repository here.
Bug reporting
Please report bugs here.


Dungeon Master Pro Character Sheet
Character
Home
Create New ...
My Characters
{{value}}
Reference Data
{{menuItem}}
Weapons, Armor and Equipment
{{key}}


Ayomide Oyekanmi
Some Information:
- 1998 - Born in Lagos, Nigeria
- 2008 - Graduated as Salutatorian from Corona Secondary School
- 2017 - Did a Spring Internship at Goldman Sachs
- 2018 - Did a Summer Internship at Goldman Sachs
- 2018 - Graduated as 4th best student in the Computer Science Department (with a First Class)
Find out more here.


Go to the source code of this file.
Defines | |
| #define | LIGHT_LEFT ADC_Conversion(3) |
| #define | LIGHT_MIDDLE ADC_Conversion(2) |
| #define | LIGHT_RIGHT ADC_Conversion(1) |
| #define | FRONT_IR front_dist_mm() |
| #define | FCPU 11059200ul |
Functions | |
| void | port_init () |
| void | timer5_init () |
| void | velocity (unsigned char, unsigned char) |
| void | motors_delay () |
| unsigned char | ADC_Conversion (unsigned char) |
| void | adc_pin_config (void) |
| void | init_adc () |
Variables | |
| unsigned char | ADC_Value |
| unsigned char | flag = 0 |
| unsigned char | Left_white_line = 0 |
| unsigned char | Center_white_line = 0 |
| unsigned char | Right_white_line = 0 |
| #define FCPU 11059200ul |
Definition at line 66 of file whiteline.h.
| #define FRONT_IR front_dist_mm() |
Definition at line 61 of file whiteline.h.
| #define LIGHT_LEFT ADC_Conversion(3) |
Definition at line 57 of file whiteline.h.
| #define LIGHT_MIDDLE ADC_Conversion(2) |
Definition at line 58 of file whiteline.h.
| #define LIGHT_RIGHT ADC_Conversion(1) |
Definition at line 59 of file whiteline.h.
| unsigned char ADC_Conversion | ( | unsigned char | Ch | ) |
Definition at line 115 of file whiteline.h.
| void adc_pin_config | ( | void | ) |
Definition at line 83 of file whiteline.h.
| void init_adc | ( | ) |
Definition at line 105 of file whiteline.h.
| void motors_delay | ( | ) |
| void port_init | ( | ) |
| void timer5_init | ( | ) |
| unsigned char ADC_Value |
Definition at line 74 of file whiteline.h.
| unsigned char Center_white_line = 0 |
Definition at line 77 of file whiteline.h.
| unsigned char flag = 0 |
Definition at line 75 of file whiteline.h.
| unsigned char Left_white_line = 0 |
Definition at line 76 of file whiteline.h.
| unsigned char Right_white_line = 0 |
Definition at line 78 of file whiteline.h.


File interactions limited to fields
Unused files deleted after 6 hours
Cannot reuse files
Cannot add fields to files
drupal.org/project/file_entity
File listing page
Adding files (and archives of files)
Managing files independently
File types
Managing fields on files
Managing file display
Simple HTML5 field formatters for audio and video files
Download link formatter
This module allows you to "lock" files so they cannot be deleted.
Media Browser widget for file and image fields
Media Browser Upload
Media Browser Views integration
Media Browser Web
drupal.org/project/media_oembed
For remote resources (YouTube, Vimeo, etc)
drupal.org/project/media_ckeditor
Whew
File interactions still limited to fields
Unused files deleted after 6 hours
Only basic WYSIWYG embedding support for images
Cannot reuse files
Cannot add fields to files
Status: Usable - Estimate: 5-7 developer/weeks
drupal.org/project/entity_embed
Completed:
Remaining:
Abstraction of reusable embedding concepts from Entity Embed.
Allows embedding of URLs using the WYSIWYG or link fields.
Using the Embed library from github.com/oscarotero/Embed
supports much more than just oEmbed
Transform pasted embeddable URLs and embed codes in WYSIWYG to normalized HTML tag.
Custom "macros" to convert shortcodes to rendered HTML.
My callout text
drupal.org/project/entity_browser
Completed:
Remaining:
drupal.org/project/inline_entity_form
Completed:
Remaining:
drupal.org/project/file_entity
Extends core's file entity type with fieldability and add/edit/delete forms.
Need to regroup on module scope.
Unofficial port: github.com/md-systems/file_entity
drupal.org/project/media_entity
Completed:
Remaining:
https://www.drupal.org/project/crop
Provides basic API for image cropping. This module won't do much by itself. Users should pick one of UI modules that utilize this API.
Completed:
Remaining:
https://www.drupal.org/project/dropzonejs
Nice multi uploader tool.
Completed:
Remaining:
drupal.org/project/fallback_formatter
Provides a field formatter that can attempt multiple formatters and the first one that returns output for each value wins.
github.com/drupal-media/recycled_formatters
drupal.org/project/file_image_formatters
Allow formatters to be shared between image, file, and entity_reference fields.
URL for direct downloads of file entities, logging downloads, etc.
Becomes a "glue" module that brings all the components together.
Based on File Entity + Entity Browser config + Entity Embed button
drupal.org/project/media_pinkeye
First module bringing everything together to work out of the box
Based on Media Entity + Entity Browser config
We want to create provide more glue modules like this
* not a diseaseClean modular architecture
Built momentum to some extent
Collaboration
Communication
Momentum
Funding
* don't hold me on that :)


#ifndef _FASTEVENTS_H_ #define _FASTEVENTS_H_ /* NET2 is a threaded, event based, network IO library for SDL. Copyright (C) 2002 Bob Pendleton This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA If you do not wish to comply with the terms of the LGPL please contact the author as other terms are available for a fee. Bob Pendleton<EMAIL_ADDRESS>*/ #include "SDL.h" #ifdef __cplusplus extern "C" { #endif int FE_Init(void); // Initialize FE void FE_Quit(void); // shutdown FE void FE_PumpEvents(void); // replacement for SDL_PumpEvents int FE_PollEvent(SDL_Event *event); // replacement for SDL_PollEvent int FE_WaitEvent(SDL_Event *event); // replacement for SDL_WaitEvent int FE_PushEvent(SDL_Event *event); // replacement for SDL_PushEvent char *FE_GetError(void); // get the last error #ifdef __cplusplus } #endif #endif


1 reference to NormalizeSearchPaths
System.Management.Automation (1)
help\MUIFileSearcher.cs (1)
103
Collection<string> normalizedSearchPaths =
NormalizeSearchPaths
(this.Target, this.SearchPaths);


{{label}}
| Integer field | {{int_field}} |
|---|---|
| Decimal field | {{dec_field}} |
| Text field | {{text_field}} |
| Char field | {{char_field}} |
| Date field | {{date_field}} |
| Time field | {{time_field}} |
| Date+time field | {{datetime_field_label}} |
{{>head}}
| Integer field | {{int_field}} |
|---|---|
| Decimal field | {{dec_field}} |
| Text field | {{text_field}} |
| Char field | {{char_field}} |
| Date field | {{date_field}} |
| Time field | {{time_field}} |
| Date+time field | {{datetime_field_label}} |


Evaluator for clustering results. The metric computes the Silhouette measure using the squared Euclidean distance. The Silhouette is a measure for the validation of the consistency within clusters. It ranges between 1 and -1, where a value close to 1 means that the points in a cluster are close to the other points in the same cluster and far from the points of the other clusters.
ml_clustering_evaluator( x, features_col = "features", prediction_col = "prediction", metric_name = "silhouette", uid = random_string("clustering_evaluator_"), ... )
| x | A |
|---|---|
| features_col | Name of features column. |
| prediction_col | Name of the prediction column. |
| metric_name | The performance metric. Currently supports "silhouette". |
| uid | A character string used to uniquely identify the ML estimator. |
| ... | Optional arguments; currently unused. |
The calculated performance metric
if (FALSE) { sc <- spark_connect(master = "local") iris_tbl <- sdf_copy_to(sc, iris, name = "iris_tbl", overwrite = TRUE) partitions <- iris_tbl %>% sdf_random_split(training = 0.7, test = 0.3, seed = 1111) iris_training <- partitions$training iris_test <- partitions$test formula <- Species ~ . # Train the models kmeans_model <- ml_kmeans(iris_training, formula = formula) b_kmeans_model <- ml_bisecting_kmeans(iris_training, formula = formula) gmm_model <- ml_gaussian_mixture(iris_training, formula = formula) # Predict pred_kmeans <- ml_predict(kmeans_model, iris_test) pred_b_kmeans <- ml_predict(b_kmeans_model, iris_test) pred_gmm <- ml_predict(gmm_model, iris_test) # Evaluate ml_clustering_evaluator(pred_kmeans) ml_clustering_evaluator(pred_b_kmeans) ml_clustering_evaluator(pred_gmm) }