Members
(constant) elements
Retrieve elements that have data-element attribute (Read only)
(constant) functions
Set event listener that are going to be attached to elements
with data-function
(constant) options
internal dom99 options, look at dom99ConfigurationExample.js
to learn how to configure it
(constant) variables
Retrieve variable values that have been modified by d.feed or
2 way data binded element with data-variable attribute (Read only)
Methods
activate(startElement) → {Element}
Activates the DOM by reading data- attributes, starting from startElement
and walking inside its tree
Parameters:
| Name | Type | Description |
|---|---|---|
startElement |
Element |
Returns:
startElement
- Type
- Element
contextFromArray(Array) → {string}
contextFromArray joins paths to create a valid path to use with
d.variables[path]
d.elements[path]
Parameters:
| Name | Type | Description |
|---|---|---|
Array |
array |
Returns:
path
- Type
- string
contextFromElement() → {string|undefined}
Parameters:
| Type | Description |
|---|---|
| Element |
Returns:
context
- Type
- string | undefined
contextFromEvent(event) → {string}
contextFromEvent gets the starting path for an event issued inside a component
in combination with contextFromArray it allows to access sibling elements and variables
d.functions.clickedButton = (event) => {
d.elements[d.contextFromArray([contextFromEvent(event), `other`])]
.classList.add(`active`);
};
Parameters:
| Name | Type | Description |
|---|---|---|
event |
Event |
Returns:
path
- Type
- string
deleteTemplate(name)
Removes a template from the DOM and from dom99 memory
Parameters:
| Name | Type | Description |
|---|---|---|
name |
string |
feed(startPath, data, data) → {Element}
Feed data, for element with corresponding data-variable and data-list
Parameters:
| Name | Type | Description |
|---|---|---|
startPath |
string | |
data |
any | |
data |
any |
Returns:
startElement
- Type
- Element
forgetContext(path)
removes a path and all its child from the dom99 singleton memory
Removing a DOM element with .remove() or .innerHTML = `` will NOT delete
all the element references if you used the underlying nodes in dom99
A removed element will continue receive invisible automatic updates
it also takes space in the memory.
And all of this doesn't matter for 1-100 elements, but it does matter,
for an infinitely growing list
Parameters:
| Name | Type | Description |
|---|---|---|
path |
string |
getParentContext(context) → {string}
getParentContext
Parameters:
| Name | Type | Description |
|---|---|---|
context |
string |
Returns:
parentContext
- Type
- string
plugin(featureToPlugIn)
Plug in a plugin (hook) into the core functionality
Parameters:
| Name | Type | Description |
|---|---|---|
featureToPlugIn |
object |
start(dataFunctions, initialFeed, startElement, callBack) → {any}
Convenience function for activate, feed and assigning functions from
an object
Parameters:
| Name | Type | Description |
|---|---|---|
dataFunctions |
object | |
initialFeed |
object | |
startElement |
Element | |
callBack |
function |
Returns:
callBack return value
- Type
- any


EasySpin can simulate powder spectra as well as single-crystal spectra. For powder spectra, it is only necessary to specify the spin system, incl. the orientations of all the tensors within the molecule or paramagnetic center, and basic experimental parameters such as microwave frequency and magnetic field sweep range. For crystal spectra, EasySpin needs some additional information: (a) the symmetry of the crystal, (b) the orientation of the molecule or paramagnetic center within the crystal, (c) the orientation of the crystal relative to the spectrometer.
In the following, we show how to simulate a crystal spectrum, and how to simulate a series of spectra obtained by rotating a crystal in the spectrometer.
To understand the following, make sure you have read the documentation on the various frames that are used by EasySpin: the lab frame, the crystal frame, the molecular frame, and the tensor frames. This understanding is very important.
Everything below is applicable to all solid-state simulation functions: pepper (for cw EPR), salt (for ENDOR), saffron (pulse EPR). It also is applicable to functions that compute resonance frequencies and fields, such as resfields etc.
Let's start with a simple spin system and a simple cw-EPR experiment. The following simulates the powder spectrum
clear Sys.g = [2.0 2.1 2.2]; Sys.lw = 1; Exp.mwFreq = 9.5; Exp.Range = [300 350]; pepper(Sys,Exp);
In order to simulate a crystal spectrum, you need to include three additional pieces of information: (1) the symmetry of the crystal, (2) the orientation of the molecule or paramagnetic center within the crystal, (3) the orientation of the crystal in the spectrometer.
Exp.CrystalSymmetry
to give the crystal symmetry. It can be the symbol for the space group (such as 'P212121'
), the number of the space group (between 1 to 230), or the symbol of the point sub-group of the space group (such 'mmm'
or 'C2h'
). If you omit Exp.CrystalSymmetry
, it is assumed to be the simplest space group 'P1'
, with one center per unit cell.
Exp.MolFrame
to specify the orientation of the molecule (paramagnetic center) within the crystal. If there are multiple symmetry-related sites, pick one of them. Exp.MolFrame
gives the Euler angles for the transformation from the crystal frame to the molecular frame. Check out the documentation on frames for details on this. If you omit Exp.MolFrame
, then it is assumed to be [0 0 0]
. This means that the molecular frame is assumed to be collinear with the crystal frame.
Exp.CrystalOrientation
to give the orientation of the crystal in the spectrometer. This field gives the three Euler angles for the transformation from the crystal frame to the laboratory frame. See the page on frames for details.
Exp.CrystalSymmetry = 'P21/c'; % space group #14 Exp.MolFrame = [0 0 0]; % molecular frame aligned with crystal frame Exp.CrystalOrientation = [0 pi/4 0]; % crystal frame tilted against lab frame pepper(Sys,Exp);
In space group P21/c, there are four sites per unit cell. Two each are magnetically equivalent, so one expects a maximum of two lines in the spectrum. With the settings as above, you will always see only a single line in the spectrum, no matter how you align the crystal in the lab. The reason is that the g tensor frame is collinear with the crystal frame, so all four sites have the same EPR spectrum.
In order to see two lines, you need to have a tilt between the g tensor frame and the crystal frame. This can be set either in Exp.MolFrame
or in Sys.gFrame
. The first will tilt the molecular frame of the spin center, and thereby tilt all tensors of the molecule, relative to the crystal. The second will only tilt the g tensor frame (and not other tensors of the spin center) relative to the molecular frame.
(Refer to the reference page on frames for details.)
Exp.MolFrame = [20 40 10]*pi/180; pepper(Sys,Exp);
In order to simulate a series of spectra that result from the rotation of a crystal in the spectrometer, use the field Exp.SampleRotation
, which implements the sample rotation.
Let's start with a spin system and an initial crystal orientation
clear Sys.g = [2.0 2.1 2.2]; Sys.lw = 1; Exp.mwFreq = 9.5; Exp.Range = [300 350]; Exp.CrystalSymmetry = 130; Exp.MolFrame = [10 60 -34]*pi/180; % molecular frame tilted within crystal Exp.CrystalOrientation = [0 40 0]*pi/180; % initial crystal orientation in lab frame pepper(Sys,Exp);
This will give the spectrum for the initial crystal orientation. Now add the rotation axis (in lab coordinates) and the rotation angle (in radians) in Exp.SampleRotation
:
rho = deg2rad(10); % sample rotation angle (radians) nRot_L = [1;0;0]; % sample rotation axis = x axis of lab frame Exp.SampleRotation = {rho,nRot_L}; pepper(Sys,Exp);
This will give the spectrum of the crystal rotated by rho
around the rotation axis nRot_L
starting from its initial orientation given in Exp.CrystalOrientation
.
To rotate an EPR sample tube in a common setup with horizontal static field (permanent or electrmagnet) and vertical microwave magnetic field (as in cavity or dielectric resonators), the rotation axis is the laboratory x axis (nRot_L=[1;0;0]
or nRot_L='x'
). Since this is so common, for this case you can omit the axis definition. The following three forms are fully equivalent:
Exp.SampleRotation = {rho,[1;0;0]}; % most general form Exp.SampleRotation = {rho,'x'}; % shorthand notation for rotation axis Exp.SampleRotation = rho; % implies that the rotation axis is 'x'
You can simulate a series of crystal spectra that result from successive small-step rotations around the same rotation axis using a loop:
rho = deg2rad(0:15:180); % 15 degree increments for k = 1:numel(rho) Exp.SampleRotation = rho(k); [B,spc(:,k)] = pepper(Sys,Exp); end stackplot(B,spc);
In a crystal simulation, EasySpin will first determine the number of magnetically equivalent sites in the crystal from the symmetry given in Exp.CrystalSymmetry
. Then, it will simulate the EPR spectra of all sites and sum them up to obtain the overall crystal spectrum.
Occasionally, it is useful to look at the EPR spectra of the single sites separately. You can tell EasySpin to simulate only a specific subset of sites (e.g. just one) by specifying the site index in Opt.Sites
. This field should contain a list of site indices. The number of sites depends on the space group given in Exp.CrystalSymmetry
. E.g. the following set limits a crystal simulation to site 3 of the 4 magnetically distinct sites in crystal of space group no. 47.
Exp.CrystalSymmetry = 47; % space group Pmmm Opt.Sites = [1 3]; % simulate only site 3
If Opt.Sites
is empty or not given, all sites are included. In powder simulations, Opt.Sites
is ignored.


Union
Social
More1
More2
More3
More4
More5
DSA
instagram event slideshow
Apache Cordova
Connecting to Device
Device is Ready


Erasure Code Support¶
History and Theory of Operation¶
There’s a lot of good material out there on Erasure Code (EC) theory, this short introduction is just meant to provide some basic context to help the reader better understand the implementation in Swift.
Erasure Coding for storage applications grew out of Coding Theory as far back as the 1960s with the Reed-Solomon codes. These codes have been used for years in applications ranging from CDs to DVDs to general communications and, yes, even in the space program starting with Voyager! The basic idea is that some amount of data is broken up into smaller pieces called fragments and coded in such a way that it can be transmitted with the ability to tolerate the loss of some number of the coded fragments. That’s where the word “erasure” comes in, if you transmit 14 fragments and only 13 are received then one of them is said to be “erased”. The word “erasure” provides an important distinction with EC; it isn’t about detecting errors, it’s about dealing with failures. Another important element of EC is that the number of erasures that can be tolerated can be adjusted to meet the needs of the application.
At a high level EC works by using a specific scheme to break up a single data buffer into several smaller data buffers then, depending on the scheme, performing some encoding operation on that data in order to generate additional information. So you end up with more data than you started with and that extra data is often called “parity”. Note that there are many, many different encoding techniques that vary both in how they organize and manipulate the data as well by what means they use to calculate parity. For example, one scheme might rely on Galois Field Arithmetic while others may work with only XOR. The number of variations and details about their differences are well beyond the scope of this introduction, but we will talk more about a few of them when we get into the implementation of EC in Swift.
Overview of EC Support in Swift¶
First and foremost, from an application perspective EC support is totally transparent. There are no EC related external API; a container is simply created using a Storage Policy defined to use EC and then interaction with the cluster is the same as any other durability policy.
EC is implemented in Swift as a Storage Policy, see Storage Policies for complete details on Storage Policies. Because support is implemented as a Storage Policy, all of the storage devices associated with your cluster’s EC capability can be isolated. It is entirely possible to share devices between storage policies, but for EC it may make more sense to not only use separate devices but possibly even entire nodes dedicated for EC.
Which direction one chooses depends on why the EC policy is being deployed. If, for example, there is a production replication policy in place already and the goal is to add a cold storage tier such that the existing nodes performing replication are impacted as little as possible, adding a new set of nodes dedicated to EC might make the most sense but also incurs the most cost. On the other hand, if EC is being added as a capability to provide additional durability for a specific set of applications and the existing infrastructure is well suited for EC (sufficient number of nodes, zones for the EC scheme that is chosen) then leveraging the existing infrastructure such that the EC ring shares nodes with the replication ring makes the most sense. These are some of the main considerations:
- Layout of existing infrastructure.
- Cost of adding dedicated EC nodes (or just dedicated EC devices).
- Intended usage model(s).
The Swift code base does not include any of the algorithms necessary to perform the actual encoding and decoding of data; that is left to external libraries. The Storage Policies architecture is leveraged to enable EC on a per container basis – the object rings are still used to determine the placement of EC data fragments. Although there are several code paths that are unique to an operation associated with an EC policy, an external dependency to an Erasure Code library is what Swift counts on to perform the low level EC functions. The use of an external library allows for maximum flexibility as there are a significant number of options out there, each with its owns pros and cons that can vary greatly from one use case to another.
PyECLib: External Erasure Code Library¶
PyECLib is a Python Erasure Coding Library originally designed and written as part of the effort to add EC support to the Swift project, however it is an independent project. The library provides a well-defined and simple Python interface and internally implements a plug-in architecture allowing it to take advantage of many well-known C libraries such as:
- Jerasure and GFComplete at http://jerasure.org.
- Intel(R) ISA-L at http://01.org/intel%C2%AE-storage-acceleration-library-open-source-version.
- Or write your own!
PyECLib uses a C based library called liberasurecode to implement the plug in infrastructure; liberasure code is available at:
- liberasurecode: https://github.com/openstack/liberasurecode
PyECLib itself therefore allows for not only choice but further extensibility as well. PyECLib also comes with a handy utility to help determine the best algorithm to use based on the equipment that will be used (processors and server configurations may vary in performance per algorithm). More on this will be covered in the configuration section. PyECLib is included as a Swift requirement.
For complete details see PyECLib
Storing and Retrieving Objects¶
We will discuss the details of how PUT and GET work in the “Under the Hood” section later on. The key point here is that all of the erasure code work goes on behind the scenes; this summary is a high level information overview only.
The PUT flow looks like this:
- The proxy server streams in an object and buffers up “a segment” of data (size is configurable).
- The proxy server calls on PyECLib to encode the data into smaller fragments.
- The proxy streams the encoded fragments out to the storage nodes based on ring locations.
- Repeat until the client is done sending data.
- The client is notified of completion when a quorum is met.
The GET flow looks like this:
- The proxy server makes simultaneous requests to participating nodes.
- As soon as the proxy has the fragments it needs, it calls on PyECLib to decode the data.
- The proxy streams the decoded data it has back to the client.
- Repeat until the proxy is done sending data back to the client.
It may sound like, from this high level overview, that using EC is going to cause an explosion in the number of actual files stored in each node’s local file system. Although it is true that more files will be stored (because an object is broken into pieces), the implementation works to minimize this where possible, more details are available in the Under the Hood section.
Handoff Nodes¶
In EC policies, similarly to replication, handoff nodes are a set of storage nodes used to augment the list of primary nodes responsible for storing an erasure coded object. These handoff nodes are used in the event that one or more of the primaries are unavailable. Handoff nodes are still selected with an attempt to achieve maximum separation of the data being placed.
Reconstruction¶
For an EC policy, reconstruction is analogous to the process of replication for a replication type policy – essentially “the reconstructor” replaces “the replicator” for EC policy types. The basic framework of reconstruction is very similar to that of replication with a few notable exceptions:
- Because EC does not actually replicate partitions, it needs to operate at a finer granularity than what is provided with rsync, therefore EC leverages much of ssync behind the scenes (you do not need to manually configure ssync).
- Once a pair of nodes has determined the need to replace a missing object fragment, instead of pushing over a copy like replication would do, the reconstructor has to read in enough surviving fragments from other nodes and perform a local reconstruction before it has the correct data to push to the other node.
- A reconstructor does not talk to all other reconstructors in the set of nodes responsible for an EC partition, this would be far too chatty, instead each reconstructor is responsible for sync’ing with the partition’s closest two neighbors (closest meaning left and right on the ring).
Note
EC work (encode and decode) takes place both on the proxy nodes, for PUT/GET operations, as well as on the storage nodes for reconstruction. As with replication, reconstruction can be the result of rebalancing, bit-rot, drive failure or reverting data from a hand-off node back to its primary.
Performance Considerations¶
In general, EC has different performance characteristics than replicated data. EC requires substantially more CPU to read and write data, and is more suited for larger objects that are not frequently accessed (eg backups).
Operators are encouraged to characterize the performance of various EC schemes and share their observations with the developer community.
Using an Erasure Code Policy¶
To use an EC policy, the administrator simply needs to define an EC policy in swift.conf and create/configure the associated object ring. An example of how an EC policy can be setup is shown below:
[storage-policy:2]
name = ec104
policy_type = erasure_coding
ec_type = liberasurecode_rs_vand
ec_num_data_fragments = 10
ec_num_parity_fragments = 4
ec_object_segment_size = 1048576
Let’s take a closer look at each configuration parameter:
name
: This is a standard storage policy parameter. See Storage Policies for details.policy_type
: Set this toerasure_coding
to indicate that this is an EC policy.ec_type
: Set this value according to the available options in the selected PyECLib back-end. This specifies the EC scheme that is to be used. For example the option shown here selects Vandermonde Reed-Solomon encoding while an option offlat_xor_hd_3
would select Flat-XOR based HD combination codes. See the PyECLib page for full details.ec_num_data_fragments
: The total number of fragments that will be comprised of data.ec_num_parity_fragments
: The total number of fragments that will be comprised of parity.ec_object_segment_size
: The amount of data that will be buffered up before feeding a segment into the encoder/decoder. The default value is 1048576.
When PyECLib encodes an object, it will break it into N fragments. However, what is important during configuration, is how many of those are data and how many are parity. So in the example above, PyECLib will actually break an object in 14 different fragments, 10 of them will be made up of actual object data and 4 of them will be made of parity data (calculations depending on ec_type).
When deciding which devices to use in the EC policy’s object ring, be sure to carefully consider the performance impacts. Running some performance benchmarking in a test environment for your configuration is highly recommended before deployment.
To create the EC policy’s object ring, the only difference in the usage of the
swift-ring-builder create
command is the replicas
parameter. The
replicas
value is the number of fragments spread across the object servers
associated with the ring; replicas
must be equal to the sum of
ec_num_data_fragments
and ec_num_parity_fragments
. For example:
swift-ring-builder object-1.builder create 10 14 1
Note that in this example the replicas
value of 14 is based on the sum of
10 EC data fragments and 4 EC parity fragments.
Once you have configured your EC policy in swift.conf and created your object ring, your application is ready to start using EC simply by creating a container with the specified policy name and interacting as usual.
Note
It’s important to note that once you have deployed a policy and have created objects with that policy, these configurations options cannot be changed. In case a change in the configuration is desired, you must create a new policy and migrate the data to a new container.
Migrating Between Policies¶
A common usage of EC is to migrate less commonly accessed data from a more expensive but lower latency policy such as replication. When an application determines that it wants to move data from a replication policy to an EC policy, it simply needs to move the data from the replicated container to an EC container that was created with the target durability policy.
Region Support¶
For at least the initial version of EC, it is not recommended that an EC scheme span beyond a single region, neither performance nor functional validation has be been done in such a configuration.
Under the Hood¶
Now that we’ve explained a little about EC support in Swift and how to configure/use it, let’s explore how EC fits in at the nuts-n-bolts level.
Terminology¶
The term ‘fragment’ has been used already to describe the output of the EC process (a series of fragments) however we need to define some other key terms here before going any deeper. Without paying special attention to using the correct terms consistently, it is very easy to get confused in a hurry!
- chunk: HTTP chunks received over wire (term not used to describe any EC specific operation).
- segment: Not to be confused with SLO/DLO use of the word, in EC we call a segment a series of consecutive HTTP chunks buffered up before performing an EC operation.
- fragment: Data and parity ‘fragments’ are generated when erasure coding transformation is applied to a segment.
- EC archive: A concatenation of EC fragments; to a storage node this looks like an object.
- ec_ndata: Number of EC data fragments.
- ec_nparity: Number of EC parity fragments.
Middleware¶
Middleware remains unchanged. For most middleware (e.g., SLO/DLO) the fact that the proxy is fragmenting incoming objects is transparent. For list endpoints, however, it is a bit different. A caller of list endpoints will get back the locations of all of the fragments. The caller will be unable to re-assemble the original object with this information, however the node locations may still prove to be useful information for some applications.
On Disk Storage¶
EC archives are stored on disk in their respective objects-N directory based on their policy index. See Storage Policies for details on per policy directory information.
In addition to the object timestamp, the filenames of EC archives encode other information related to the archive:
The fragment archive index. This is required for a few reasons. For one, it allows us to store fragment archives of different indexes on the same storage node which is not typical however it is possible in many circumstances. Without unique filenames for the different EC archive files in a set, we would be at risk of overwriting one archive of index n with another of index m in some scenarios.
The index is appended to the filename just before the
.data
extension. For example, the filename for a fragment archive storing the 5th fragment would be:1418673556.92690#5.data
The durable state of the archive. The meaning of this will be described in more detail later, but a fragment archive that is considered durable has an additional
#d
string included in its filename immediately before the.data
extension. For example:1418673556.92690#5#d.data
A policy-specific transformation function is therefore used to build the
archive filename. These functions are implemented in the diskfile module as
methods of policy specific sub classes of BaseDiskFileManager
.
The transformation function for the replication policy is simply a NOP.
Note
In older versions the durable state of an archive was represented by an
additional file called the .durable
file instead of the #d
substring in the .data
filename. The .durable
for the example above
would be:
1418673556.92690.durable
Proxy Server¶
High Level¶
The Proxy Server handles Erasure Coding in a different manner than replication, therefore there are several code paths unique to EC policies either though sub classing or simple conditionals. Taking a closer look at the PUT and the GET paths will help make this clearer. But first, a high level overview of how an object flows through the system:
Note how:
- Incoming objects are buffered into segments at the proxy.
- Segments are erasure coded into fragments at the proxy.
- The proxy stripes fragments across participating nodes such that the on-disk stored files that we call a fragment archive is appended with each new fragment.
This scheme makes it possible to minimize the number of on-disk files given our segmenting and fragmenting.
Multi_Phase Conversation¶
Multi-part MIME document support is used to allow the proxy to engage in a handshake conversation with the storage node for processing PUT requests. This is required for a few different reasons.
- From the perspective of the storage node, a fragment archive is really just another object, we need a mechanism to send down the original object etag after all fragment archives have landed.
- Without introducing strong consistency semantics, the proxy needs a mechanism to know when a quorum of fragment archives have actually made it to disk before it can inform the client of a successful PUT.
MIME supports a conversation between the proxy and the storage nodes for every PUT. This provides us with the ability to handle a PUT in one connection and assure that we have the essence of a 2 phase commit, basically having the proxy communicate back to the storage nodes once it has confirmation that a quorum of fragment archives in the set have been written.
For the first phase of the conversation the proxy requires a quorum of ec_ndata + 1 fragment archives to be successfully put to storage nodes. This ensures that the object could still be reconstructed even if one of the fragment archives becomes unavailable. As described above, each fragment archive file is named:
<ts>#<frag_index>.data
where ts
is the timestamp and frag_index
is the fragment archive index.
During the second phase of the conversation the proxy communicates a
confirmation to storage nodes that the fragment archive quorum has been
achieved. This causes each storage node to rename the fragment archive written
in the first phase of the conversation to include the substring #d
in its
name:
<ts>#<frag_index>#d.data
This indicates to the object server that this fragment archive is durable and
that there is a set of data files that are durable at timestamp ts
.
For the second phase of the conversation the proxy requires a quorum of ec_ndata + 1 successful commits on storage nodes. This ensures that there are sufficient committed fragment archives for the object to be reconstructed even if one becomes unavailable. The reconstructor ensures that the durable state is replicated on storage nodes where it may be missing.
Note that the completion of the commit phase of the conversation is also a signal for the object server to go ahead and immediately delete older timestamp files for this object. This is critical as we do not want to delete the older object until the storage node has confirmation from the proxy, via the multi-phase conversation, that the other nodes have landed enough for a quorum.
The basic flow looks like this:
- The Proxy Server erasure codes and streams the object fragments (ec_ndata + ec_nparity) to the storage nodes.
- The storage nodes store objects as EC archives and upon finishing object data/metadata write, send a 1st-phase response to proxy.
- Upon quorum of storage nodes responses, the proxy initiates 2nd-phase by sending commit confirmations to object servers.
- Upon receipt of commit message, object servers rename
.data
files to include the#d
substring, indicating successful PUT, and send a final response to the proxy server.- The proxy waits for ec_ndata + 1 object servers to respond with a success (2xx) status before responding to the client with a successful status.
Here is a high level example of what the conversation looks like:
proxy: PUT /p/a/c/o
Transfer-Encoding': 'chunked'
Expect': '100-continue'
X-Backend-Obj-Multiphase-Commit: yes
obj: 100 Continue
X-Obj-Multiphase-Commit: yes
proxy: --MIMEboundary
X-Document: object body
<obj_data>
--MIMEboundary
X-Document: object metadata
Content-MD5: <footer_meta_cksum>
<footer_meta>
--MIMEboundary
<object server writes data, metadata to <ts>#<frag_index>.data file>
obj: 100 Continue
<quorum>
proxy: X-Document: put commit
commit_confirmation
--MIMEboundary--
<object server renames <ts>#<frag_index>.data to <ts>#<frag_index>#d.data>
obj: 20x
<proxy waits to receive >=2 2xx responses>
proxy: 2xx -> client
A few key points on the durable state of a fragment archive:
- A durable fragment archive means that there exist sufficient other fragment archives elsewhere in the cluster (durable and/or non-durable) to reconstruct the object.
- When a proxy does a GET, it will require at least one object server to respond with a fragment archive is durable before reconstructing and returning the object to the client.
Partial PUT Failures¶
A partial PUT failure has a few different modes. In one scenario the Proxy Server is alive through the entire PUT conversation. This is a very straightforward case. The client will receive a good response if and only if a quorum of fragment archives were successfully landed on their storage nodes. In this case the Reconstructor will discover the missing fragment archives, perform a reconstruction and deliver those fragment archives to their nodes.
The more interesting case is what happens if the proxy dies in the middle of a conversation. If it turns out that a quorum had been met and the commit phase of the conversation finished, its as simple as the previous case in that the reconstructor will repair things. However, if the commit didn’t get a chance to happen then some number of the storage nodes have .data files on them (fragment archives) but none of them knows whether there are enough elsewhere for the entire object to be reconstructed. In this case the client will not have received a 2xx response so there is no issue there, however, it is left to the storage nodes to clean up the stale fragment archives. Work is ongoing in this area to enable the proxy to play a role in reviving these fragment archives, however, for the current release, a proxy failure after the start of a conversation but before the commit message will simply result in a PUT failure.
GET¶
The GET for EC is different enough from replication that subclassing the BaseObjectController to the ECObjectController enables an efficient way to implement the high level steps described earlier:
- The proxy server makes simultaneous requests to ec_ndata primary object server nodes with goal of finding a set of ec_ndata distinct EC archives at the same timestamp, and an indication from at least one object server that a durable fragment archive exists for that timestamp. If this goal is not achieved with the first ec_ndata requests then the proxy server continues to issue requests to the remaining primary nodes and then handoff nodes.
- As soon as the proxy server has found a usable set of ec_ndata EC archives, it starts to call PyECLib to decode fragments as they are returned by the object server nodes.
- The proxy server creates Etag and content length headers for the client response since each EC archive’s metadata is valid only for that archive.
- The proxy streams the decoded data it has back to the client.
Note that the proxy does not require all objects servers to have a durable fragment archive to return in response to a GET. The proxy will be satisfied if just one object server has a durable fragment archive at the same timestamp as EC archives returned from other object servers. This means that the proxy can successfully GET an object that had missing durable state on some nodes when it was PUT (i.e. a partial PUT failure occurred).
Note also that an object server may inform the proxy server that it has more than one EC archive for different timestamps and/or fragment indexes, which may cause the proxy server to issue multiple requests for distinct EC archives to that object server. (This situation can temporarily occur after a ring rebalance when a handoff node storing an archive has become a primary node and received its primary archive but not yet moved the handoff archive to its primary node.)
The proxy may receive EC archives having different timestamps, and may receive several EC archives having the same index. The proxy therefore ensures that it has sufficient EC archives with the same timestamp and distinct fragment indexes before considering a GET to be successful.
Object Server¶
The Object Server, like the Proxy Server, supports MIME conversations as described in the proxy section earlier. This includes processing of the commit message and decoding various sections of the MIME document to extract the footer which includes things like the entire object etag.
DiskFile¶
Erasure code policies use subclassed ECDiskFile
, ECDiskFileWriter
,
ECDiskFileReader
and ECDiskFileManager
to implement EC specific
handling of on disk files. This includes things like file name manipulation to
include the fragment index and durable state in the filename, construction of
EC specific hashes.pkl
file to include fragment index information, etc.
Metadata¶
There are few different categories of metadata that are associated with EC:
System Metadata: EC has a set of object level system metadata that it attaches to each of the EC archives. The metadata is for internal use only:
X-Object-Sysmeta-EC-Etag
: The Etag of the original object.X-Object-Sysmeta-EC-Content-Length
: The content length of the original object.X-Object-Sysmeta-EC-Frag-Index
: The fragment index for the object.X-Object-Sysmeta-EC-Scheme
: Description of the EC policy used to encode the object.X-Object-Sysmeta-EC-Segment-Size
: The segment size used for the object.
User Metadata: User metadata is unaffected by EC, however, a full copy of the user metadata is stored with every EC archive. This is required as the reconstructor needs this information and each reconstructor only communicates with its closest neighbors on the ring.
PyECLib Metadata: PyECLib stores a small amount of metadata on a per fragment basis. This metadata is not documented here as it is opaque to Swift.
Database Updates¶
As account and container rings are not associated with a Storage Policy, there is no change to how these database updates occur when using an EC policy.
The Reconstructor¶
The Reconstructor performs analogous functions to the replicator:
- Recovering from disk drive failure.
- Moving data around because of a rebalance.
- Reverting data back to a primary from a handoff.
- Recovering fragment archives from bit rot discovered by the auditor.
However, under the hood it operates quite differently. The following are some of the key elements in understanding how the reconstructor operates.
Unlike the replicator, the work that the reconstructor does is not always as easy to break down into the 2 basic tasks of synchronize or revert (move data from handoff back to primary) because of the fact that one storage node can house fragment archives of various indexes and each index really “belongs” to a different node. So, whereas when the replicator is reverting data from a handoff it has just one node to send its data to, the reconstructor can have several. Additionally, it is not always the case that the processing of a particular suffix directory means one or the other job type for the entire directory (as it does for replication). The scenarios that create these mixed situations can be pretty complex so we will just focus on what the reconstructor does here and not a detailed explanation of why.
Job Construction and Processing¶
Because of the nature of the work it has to do as described above, the reconstructor builds jobs for a single job processor. The job itself contains all of the information needed for the processor to execute the job which may be a synchronization or a data reversion. There may be a mix of jobs that perform both of these operations on the same suffix directory.
Jobs are constructed on a per-partition basis and then per-fragment-index basis. That is, there will be one job for every fragment index in a partition. Performing this construction “up front” like this helps minimize the interaction between nodes collecting hashes.pkl information.
Once a set of jobs for a partition has been constructed, those jobs are sent off to threads for execution. The single job processor then performs the necessary actions, working closely with ssync to carry out its instructions. For data reversion, the actual objects themselves are cleaned up via the ssync module and once that partition’s set of jobs is complete, the reconstructor will attempt to remove the relevant directory structures.
Job construction must account for a variety of scenarios, including:
- A partition directory with all fragment indexes matching the local node index. This is the case where everything is where it belongs and we just need to compare hashes and sync if needed. Here we simply sync with our partners.
- A partition directory with at least one local fragment index and mix of others. Here we need to sync with our partners where fragment indexes matches the local_id, all others are sync’d with their home nodes and then deleted.
- A partition directory with no local fragment index and just one or more of others. Here we sync with just the home nodes for the fragment indexes that we have and then all the local archives are deleted. This is the basic handoff reversion case.
Note
A “home node” is the node where the fragment index encoded in the fragment archive’s filename matches the node index of a node in the primary partition list.
Node Communication¶
The replicators talk to all nodes who have a copy of their object, typically just 2 other nodes. For EC, having each reconstructor node talk to all nodes would incur a large amount of overhead as there will typically be a much larger number of nodes participating in the EC scheme. Therefore, the reconstructor is built to talk to its adjacent nodes on the ring only. These nodes are typically referred to as partners.
Reconstruction¶
Reconstruction can be thought of sort of like replication but with an extra step in the middle. The reconstructor is hard-wired to use ssync to determine what is missing and desired by the other side. However, before an object is sent over the wire it needs to be reconstructed from the remaining fragments as the local fragment is just that - a different fragment index than what the other end is asking for.
Thus, there are hooks in ssync for EC based policies. One case would be for basic reconstruction which, at a high level, looks like this:
- Determine which nodes need to be contacted to collect other EC archives needed to perform reconstruction.
- Update the etag and fragment index metadata elements of the newly constructed fragment archive.
- Establish a connection to the target nodes and give ssync a DiskFileLike class from which it can stream data.
The reader in this class gathers fragments from the nodes and uses PyECLib to
reconstruct each segment before yielding data back to ssync. Essentially what
this means is that data is buffered, in memory, on a per segment basis at the
node performing reconstruction and each segment is dynamically reconstructed and
delivered to ssync_sender
where the send_put()
method will ship them on
over. The sender is then responsible for deleting the objects as they are sent
in the case of data reversion.
The Auditor¶
Because the auditor already operates on a per storage policy basis, there are no specific auditor changes associated with EC. Each EC archive looks like, and is treated like, a regular object from the perspective of the auditor. Therefore, if the auditor finds bit-rot in an EC archive, it simply quarantines it and the reconstructor will take care of the rest just as the replicator does for replication policies.


ArcadeGo
Home
Login
About
Information
First name:
Last name:
Gender:
Male
Female
Birthday:
ID:
Password:
Login


Quick Learner,Open to new technologies, Data Structure & Algorithm Enthusiastic.
I have a good understanding of web technologies along with decent knowledge of Java, C, C++, Python and can create code from scratch.
With a basic knowledge of GIT and GitHub, and involved in OpenSource community.
Solid understanding of Data Structure and Algorithms along with the knowledge in HTML5 and CSS3 and can understand and edit the Python scripts and JavaScript ,SQL and Databases.
Let's CONNECT...
Nov-2015 - Present
May-2015 - July-2015
I was a summer intern at Step Ahead Technologies Inc. for 3 months. I dealt with the back end technologies mainly focusing on SQl and Databases for the company's internal requirement. I was appreciated for my work there.
May-2014 - June-2014
National Fertilizers Limited is a government of India undertaking public sector undertaking. My basic job was to understand the Significance and the implementation of Networking in public undertaking company. Functioning of Ammonia plant and the process of fertilizer was further explained.
Claim policy Portal is a responsive web application. It allows it's customer to claim all the policies at one platform in a very easy and quick way. Admin will approve the claim if the claim is valid otherwise he will reject it. Thus in a very simpler way one can claim the policy.
Mobile recharge portal is an online recharge web application linked with a dummy bank named SRS Bank which allows its customer to recharge his or her mobile in go. The customer gets the privilege to get recharge done of any service provider.
We developed an algorithm which provided a connection between various node in a wireless network and also provided security in it.
Click here to view the certificate
Click here to view the certificate
I love to learn different things and do different projects to learn new technologies and produce something innovative out of it.
I am fast learner and is ready to learn whatever comes to me as a challenge.
I am actively participating in sport programming and is able to solve different challenges quickly.
I have completed B.E degree from Lakshmi Narian College of Technology and Science Bhopal with a Discipline in CSE having strong communication, collaboration and interpersonal skills with proficiency in grasping new technical concepts quickly and utilizing them in an effective manner. Right now, I work at Infosys as a System and Software Engineer.
I am seeking technical Job Opportunities which can exploit the best from me and help me progress and prosper.I am also seeking a longer term relationship.
Let's connect with E-Mail
Shikha Badkul


Source File
stubs_amd64.go
Belonging Package
runtime
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package runtime
// Called from compiled code; declared for vet; do NOT call from Go.
func ()
func ()
func ()
func ()
func ()
func ()
func ()
// stackcheck checks that SP is in range [g->stack.lo, g->stack.hi).
func ()
// Called from assembly only; declared for go vet.
func () // argument in DI
// Retpolines, used by -spectre=ret flag in cmd/asm, cmd/compile.
func ()
func ()
func ()
func ()
func ()
func ()
func ()
func ()
func ()
func ()
func ()
func ()
func ()
func ()
func ()
The pages are generated with Golds v0.2.7-preview. (GOOS=darwin GOARCH=amd64)


UKCloud Limited (“UKC”) and Virtual Infrastructure Group Limited (“VIG”) (together “the Companies”) – in Compulsory Liquidation
On 25 October 2022, the Companies were placed into Liquidation with the Official Receiver appointed as Liquidator and J Robinson and A M Hudson simultaneously appointed as Special Managers to manage the liquidation process on behalf of the Official Receiver.
Further information regarding the Liquidations can be found here: https://www.gov.uk/government/news/virtual-infrastructure-group-limited-and-ukcloud-limited-information-for-creditors-and-interested-parties
Contact details:
For any general queries relating to the Liquidations please email<EMAIL_ADDRESS>For customer related queries please email<EMAIL_ADDRESS>For supplier related queries please email<EMAIL_ADDRESS>Self Service Backup and Restoration (TrilioVault) Service Scope
General
This article explains what is and isn't included in the scope of the OpenStack Self Service Backup and Restoration (TrilioVault) service option.
TrilioVault is one of a variety of on-platform protection options available from UKCloud. Use this article to understand instance backup and restoration and whether it will meet your own recovery point (RPO) or recovery time (RTO) objectives.
About Self Service Backup and Restoration (TrilioVault)
When you opt an OpenStack instance into the TrilioVault service, the instance is added to your TrilioVault self-service dashboard within OpenStack. Backups are made of the entire instance running on your UKCloud for OpenStack service.
Data protected by this service has a variable RPO dictated by the frequency of backups scheduled by the end user. RTO is determined by the time taken to restore the backup once you've instantiated it via the OpenStack dashboard.
Self Service Backup and Restoration management
You can make changes to your Backup and Restoration service directly via the OpenStack dashboard. You can:
Opt instances into the service
Change the backup policy for an instance
Opt instances out of the backup service
Instantiate the restoration of entire instances from an existing backup
Instantiate the restoration of an individual file from an existing backup
Restores
As a fully self-service function, customers can invoke their own restorations of either an entire instance or individual files via the OpenStack dashboard.
How is Self Service Backup and Restoration (TrilioVault) charged?
TrilioVault is chargeable based on the number of instances protected and the capacity utilised to store the data.
[!NOTE] The TrilioVault platform leverages cinder snapshots to get the data backed up. It initiates a snapshot for the initial full backup and leaves the snapshot there to use as the differential for the next incremental backup. At any given time, there could be up to two snapshots visible per volume being backed up. At the end of the backup, there should only be one left behind (used for next incremental). In short we would not recommend deleting any TrilioVault snapshots as this will impact upon the performance of your backup routine.
How can TrilioVault be used as a Disaster Recovery (DR) tool?
By default, TrilioVault is not a DR tool, however in the event UKCloud declares a DR scenario in your primary datacentre, we can repoint TrilioVault to make your backup target site also become the recovery site, ensuring we can restore any and all workloads to a secondary datacentre in the event of a disaster event in your primary datacentre.
Frequency and timing
As TrilioVault is fully self-service, customers have full control as to the time and frequency that any backups occur.
Alerting and reporting
Information about your backups is reported via the OpenStack dashboard, where the status of all backup and restoration events can be monitored in real time.
Success rate
We do not guarantee successful backups, but we provide customers with full visibility as to the status of any backups along with the ability for customers to re-instantiate any backups that fail to complete.
Rerun of failed backups
The onus is on the customer to monitor the success of their backups via the tools made available within OpenStack. UKCloud will not automatically invoke any reruns of failed backups.
What SLA do you offer on snapshot success?
TrilioVault backups don't include an SLA. You should be aware that backups may occasionally fail for a variety of reasons. The status of TrilioVault backups should be monitored by the customer via the OpenStack dashboard.
This service is not backed by Service Credits.
The UKCloud support team can help provide customers with the support around investigating any failures on request.
Planned Maintenance
On occasion, Planned Maintenance of the OpenStack platform will take precedence over this service. If there's a potential disruption, we'll highlight this to you via the UKCloud Service Status page.
Additional data protection services
[!NOTE] No protection products are automatically applied to instances running on the UKCloud platform, therefore you must explicitly select the protection option that best meets your requirements.
UKCloud for OpenStack also offers self-service snapshot protection natively from within the platform should you not require the advanced features of TrilioVault.
If neither of these services meet your requirements, you can also implement and manage your own protection solution. The UKCloud Cloud Storage service may be an appropriate target for self-managed solutions using software such as CommVault or NetWorker.
Feedback
If you find a problem with this article, click Improve this Doc to make the change yourself or raise an issue in GitHub. If you have an idea for how we could improve any of our services, send an email to feedback@ukcloud.com.


Brett Zamir
on 2012-06-22 06:21:03
@Matteo: Your escape sequence (i.e., the part with "necessit%E0") is not using UTF-8. That is what JavaScript uses, and really what you should render in PHP (via header() and content-type).
@jeicquest, @Zaide: I have hopefully taken into account your issues. Zaide, I did my own implementation in order to support multi-dimensional arrays/objects while removing eval().
@David Pesta: I agree. I have changed to an object literal instead of array.
jeicquest
on 2012-05-29 15:04:23
line:24+
reset = 0,
line:80-90
for (j = 0; j < keys.length; j++) {
key = keys[j];
if ((key !== '' && key !== ' ') || j === 0) {
key = "'" + key + "'";
} else {
key = "'" + reset + "'";
reset++;
//key = eval(evalStr + '.push([]);') - 1;
}
evalStr += '[' + key + ']';
if (j !== keys.length - 1 && eval('typeof ' + evalStr) === 'undefined') {
eval(evalStr + ' = {};');
reset = 0;
}
}
David Pesta
on 2012-01-02 04:19:49
tl;dr - On line 89, change [] to {} so that it reads: eval(evalStr + ' = {};');
Many of the array functions in the php.js library return javascript objects instead of javascript arrays, which is good. Javascript objects are much more PHPish than javascript arrays. But this function returns a javascript array instead of a javascript object, which can lead to unexpected problems if you are expecting this to behave like PHP (namely, a large number as a key will cause the javascript array to add null values in all of its indexes up to the value of that key, where in PHP it won't do that--pretty frustrating). To fix this, simply replace the [] with {} inside the eval on line 89 where the parent "arrays" are iteratively created. This will make it create objects instead.
Matteo
on 2010-11-17 10:08:47
using the function as described above, this string
"name=98_20&id_azienda=3&id_sede=12&revisione=0&selectFolder=linee&module_from=98_20&id_from=&id_orig=0&nome=Promemoria+pianificazione+prossimo+audit&descrizione=Promemoria+per+la+necessit%E0+di+pianificare+il+prossimo+audit&id_assegnatario=1&nome_assegnatario=SYSTEM"
causes a "malformed URI sequence" error.
How can we solve it? I do not see any error in the query string.
Zaide
on 2010-10-12 11:08:48
I was going to use this code then i saw the evals so i reimplemented it to this. Its faster, passes lint and its eval free :). I tested every make up of a query string i could think of and they all come out the same as the parse_str code above.
function parse_str_new (str, arr){
var strArr = (str+'').replace(/^&/, '').replace(/&$/, '').split('&'),
i,
tmp,
key,
value,
keyIndex,
subkey,
fixStr = function (str) {
return decodeURIComponent(str.replace(/\+/g, '%20'));
};
if (!arr) {
arr = this.window;
}
for (i = 0; i < strArr.length; i++) {
tmp = strArr[i].split("=");
key = fixStr(tmp[0]);
if(tmp.length < 2){
value = "";
}else{
value = fixStr(tmp[1]);
}
while (key.charAt(0) === ' ') {
key = key.substr(1);
}
if (key.indexOf("\x00") !== -1) {
key = key.substr(0, key.indexOf("\x00"));
}
if (key && key.charAt(0) !== '[') {
keyIndex = key.indexOf('[');
if(keyIndex !== -1&&key.indexOf(']',keyIndex) !== -1){
subkey = key.substring(keyIndex+1,key.indexOf(']',keyIndex));
key = key.substring(0,keyIndex).replace(/\.| /g,'_');
if(!arr[key]){
arr[key]=[];
}
if(subkey === ""){
arr[key].push(value);
}else{
arr[key][subkey]=value;
}
}else{
arr[key.replace(/\.| |\[/g,"_")] = value;
}
}
}
}
Brett Zamir
on 2010-09-14 05:55:39
@e-mike. Thanks for the report. I had just assumed that was some cascading error that would be fixed by the fix I made, but now I've also addressed the urldecode issue you mention so the error should indeed now be avoided. (I'm just taking your word for it that PHP silently ignores missing, empty or null values, as I haven't confirmed in this case.) (I also just now simplified and expanded my earlier parse_str fix.)
e-mike
on 2010-09-13 18:03:00
The TypeError mentioned by Dreamer is still there (also in the git version).
The error is caused by urldecode (not parse_str). urldecode had a makeover not long ago and the error is since the makeover.
If the string (str) is empty, undefined or not a string you get this error.
Kevin van Zonneveld
on 2010-09-08 19:32:45
Awesome
Brett Zamir
on 2010-08-16 03:55:35
@Dreamer: Fixed in Git. Thanks for the report!
Dreamer
on 2010-08-15 16:10:15
Bug report --- "TypeError: str.replace is not a function" (Copied from FireBug)
// PHPJS cannot parse the following codes, while it's possible in PHP
parse_str('&first=foo');
parse_str('first=foo&');
parse_str('&first=foo&');
Kevin van Zonneveld
on 2010-06-19 15:30:38
@ droope: Although there are plenty open jslint issues with this function, i is actually defined and in my tests it works. What platform are you experiencing issues on?
droope
on 2010-05-15 13:55:26
Hi.
I keep getting "i is not defined". Perhaps something broke?
Regards,
Droope
Brett Zamir
on 2009-05-03 03:12:03
Thanks much, stag019... Fixed in SVN (including moving equality operators to identity ones)...
stag019
on 2009-05-02 22:31:29
Two things I forgot to mention:
Depends on urldecode now.
Some places I use '==' or '!=' where I could probably use '===' or '!=='. These should probably be fixed.
stag019
on 2009-05-02 22:07:03
Well, time to bugfix myself. ;P
Looking through the PHP source I realized I completely neglected to test anything with a null character in it. Aparently PHP completely ignores everything after a null character in the key name, but leaves it alone in the value.
Change the function fixStr to return urldecode(str).replace(/([\\"'])/g, '\\$1').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
Underneath while(key.charAt(0) === ' ')
{
key = key.substr(1);
}
add if(key.indexOf('\0') !== -1)
{
key = key.substr(0, key.indexOf('\0'));
}
Brett Zamir
on 2009-04-30 05:50:38
Looks good, stag019, thanks! Added in SVN. (Netbeans just caught the fact that "chr" needed to be declared too.). If you like, you might also consider voting for https://bugzilla.mozilla.org/show_bug.cgi?id=488227 as this is one behavior JS can't emulate from many PHP functions (in this case, we'd get a way to use parse_str() to put variables into a local scope only without using an array).
stag019
on 2009-04-30 00:52:06
Oops, I also forgot to mention that the second parameter is now optional, as it uses the window variable if none is defined.
stag019
on 2009-04-30 00:35:16
Sure, it parses strings such as array[key]=value into an array, in the same fashion PHP does. It also handles the encoding of the period and space characters, in the same fashion that PHP does.
Kevin van Zonneveld
on 2009-04-29 15:25:02
stag019: Sorry but there are a lot function we need to maintain. Would it be possible for you to explain how your implementation beats our current one?
stag019
on 2009-04-27 21:13:29
I couldn't think of a way to do it without eval(), but it better emulates PHP.
function parse_str(str, array)
{
var glue1 = '=', glue2 = '&', array2 = String(str).split(glue2),
i, j, tmp, key, value, bracket, keys, evalStr,
fixStr = function(str)
{
return urldecode(str).replace(/([\\"'])/g, '\\$1').replace(/\0/g, '\\0').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
};
if(!array)
{
array = window;
}
for(i = 0; i < array2.length; i++)
{
tmp = array2[i].split(glue1);
if(tmp.length < 2)
{
tmp = [tmp, ''];
}
key = fixStr(tmp[0]);
value = fixStr(tmp[1]);
while(key.charAt(0) == ' ')
{
key = key.substr(1);
}
if(key && key.charAt(0) != '[')
{
keys = [];
bracket = 0;
for(j = 0; j < key.length; j++)
{
if(key.charAt(j) == '[' && !bracket)
{
bracket = j + 1;
}
else if(key.charAt(j) == ']')
{
if(bracket)
{
if(!keys.length)
{
keys.push(key.substr(0, bracket - 1));
}
keys.push(key.substr(bracket, j - bracket));
bracket = 0;
if(key.charAt(j + 1) !== '[')
{
break;
}
}
}
}
if(!keys.length)
{
keys = [key];
}
for(j = 0; j < keys[0].length; j++)
{
chr = keys[0].charAt(j);
if(chr == ' ' || chr == '.' || chr == '[')
{
keys[0] = keys[0].substr(0, j) + '_' + keys[0].substr(j + 1);
}
if(chr == '[')
{
break;
}
}
evalStr = 'array';
for(j = 0; j < keys.length; j++)
{
key = keys[j];
if((key !== '' && key !== ' ') || j === 0)
{
key = "'" + key + "'";
}
else
{
key = eval(evalStr + '.push([]);') - 1;
}
evalStr += '[' + key + ']';
if(j != keys.length - 1 && eval('typeof ' + evalStr) == 'undefined')
{
eval(evalStr + ' = [];');
}
}
evalStr += " = '" + value + "';\n";
eval(evalStr);
}
}
}
Kevin van Zonneveld
on 2008-03-03 11:47:52
@ Michael White: great! thank you!
Michael White
on 2008-03-02 22:00:39
This function did not take into account the fact that the URL string might be encoded so I modified it to handle encoded URLs and added a new example.
function parse_str(str, array){
// http://kevin.vanzonneveld.net
// + original by: Cagri Ekin
// * example 1: parse_str('first=foo&second=bar');
// * returns 1: { first: 'foo', second: 'bar' }
// * example 2: parse_str('str_a=Jack+and+Jill+didn%27t+see+the+well.');
// * returns 2: { str_a: "Jack and Jill didn't see the well." }
var glue1 = '=';
var glue2 = '&';
var array2 = str.split(glue2);
var array3 = [];
for(var x=0; x<array2.length; x++){
var tmp = array2[x].split(glue1);
array3[unescape(tmp[0])] = unescape(tmp[1]).replace(/[+]/g, ' '); // This is the modified line.
}
if(array){
array = array3;
} else {
return array3;
}
}
http://crestidg.com


x
Before You Go, Get Our Best Deal
3 Years For The Price Of 2!*
62% Off!
*Special offers are limited-time promotional prices available to new customers and are valid for the initial term only, not for successive or renewal periods. Discount applied to regular rate.


Log In
Register
Remember Password
Sign In
I agree to the Terms & Conditions
I agree to the privacy policy
Register


Ceres Solver¶
Ceres Solver [1] is an open source C++ library for modeling and solving large, complicated optimization problems. It can be used to solve Non-linear Least Squares problems with bounds constraints and general unconstrained optimization problems. It is a mature, feature rich, and performant library that has been used in production at Google since 2010. For more, see Why?.
<EMAIL_ADDRESS>is the place for discussions and questions about Ceres Solver. We use the GitHub Issue Tracker to manage bug reports and feature requests.
Cite Us¶
If you use Ceres Solver for a publication, please cite it as:
@misc{ceres-solver,
author = "Sameer Agarwal and Keir Mierle and Others",
title = "Ceres Solver",
howpublished = "\url{http://ceres-solver.org}",
}
Footnotes
| [1] | While there is some debate as to who invented the method of Least Squares [Stigler], there is no questioning the fact that it was Carl Friedrich Gauss who brought it to the attention of the world. Using just 22 observations of the newly discovered asteroid Ceres, Gauss used the method of least squares to correctly predict when and where the asteroid will emerge from behind the Sun [TenenbaumDirector]. We named our solver after Ceres to celebrate this seminal event in the history of astronomy, statistics and optimization. |


Technical posts on networking, automation and career
Home
About
Site Archives
Post Categories
Content Tags
routetonull.
the jabberings of a networking guy
Site Archives
2017
November
30 November 2017
·
ArubaOS 8 centralized upgrade
2016
December
12 December 2016
·
Change of scenery
2014
July
22 July 2014
·
HP´s response to Meraki is here
May
20 May 2014
·
Cisco Prime Infrastructure 2.1
13 May 2014
·
IMC UAM Radius and IPv6
9 May 2014
·
IMC operator LDAP / SSL authentication
6 May 2014
·
IMC 7.0 E0202
March
5 March 2014
·
The starting point of my new blog


PhaserJS Game by
Devahoy
Source Code on
Github
Learn Phaser JS From
HTML5 Shoot 'em Up in an Afternoon


CPQ - Configure Price Quote
Front-End Development
I alone handled the CSS development of CPQ - a product used by Comcast, one of the biggest clients of Amdocs. I delivered New Look & Feel project and SMB project for development in tight deadlines. I was the focal for various sides of the product like delivery, design and core. During this term, I was able to learn and apply SASS - Syntactically Awesome Stylesheets in the product.


Bedsitter SQ
Jamuhuri EState
Beditter SQ for rent in Jamuhuri 1
1 Bedroom Apartments
Ayani, Kibra
Classic 1 Bedroom In Kibra For Rent
1
Bedsitter SQ,
Embulbul,Ngong
Bedsitter SQ for Rent 1


Marcus Daly Time Trial and Criterium
(Montana State Championships)
Hamilton, Montana
August Third and Fourth 2002
$ 300 prize purse
Time Trial Registration- Saturday 2 pm to 4 pm at Valley Bike and Ski in Hamilton on Highway 93 (219 S. First) just South of Main Street.
Time Trial Racing- First rider off at 5pm Saturday. Riders will go by division in the following order: (Masters 45+, Masters 25-44, Juniors, Cat 4,5 Men, Women 1,2,3,4, Cat 1,2,3 Men)
Time Trial Course- 40k (24.8 miles) located just Southeast of Hamilton on Sleeping Child Road. Course is slight uphill out, fast downhill back.
Criterium Registration-Saturday 2pm to 4 pm at Valley Bike and Ski and 7 am to 8:30 am on Sunday morning at the Start Finish line on Main Street.
Criterium Racing- Sunday-9:00 am Masters and Juniors (40 minutes); 10:50- Cat 4,5 men (40 minutes); 11:40 Women 1,2,3,4 (40 minutes); Men 1,2,3 (50 minutes)
Criterium Course-- Downtown Hamilton, L shaped course with 5 right turns and one left turn; fast and flat
Medals and Cash to top three in each race.
Entry Fee is $ 16 for both Crit and TT, $ 12 for either Crit or TT
No pre-registration, register at race.
Race Director- Randy Lavall<PHONE_NUMBER>
Sponsored By Valley Bike and Ski
Promoted By Team Stampede / Five Valley Velo
USCF Permit Pending


{% from "_formhelpers.html" import render_field %}
Here at PowellTech, you're more than a repair number. We value and
appreciate you as a customer. That is why we believe in
relationships, and ensuring that even after your repair is
complete, we attempt to establish a relationship with you; we
attempt to solve all of your problems and keep your technology in
your hands. If at any point you feel as if we are not honoring our
beliefs, please feel free to contact us. We
would love to hear from you and attempt to improve your PowellTech
experience.
-PowellTech
Our vision at PowellTech is to ensure that you receive a timely, thorough, and effective repair to keep your technology in your hands. We are quickly evolving into a world solely reliant upon technology, we simply want to keep you functioning. If at any point you feel as if we are not honoring our beliefs, please feel free to contact us. We would love to hear from you and attempt to improve your PowellTech experience.
PowellTech supports Apple computers ranging from years Early 2012 to Late 2018.
You can rest assured, all of our PowellTechnichians are Apple certified.
OS X Yosemite - macOS Mojave
PowellTech also supports Windows computers from various hardware manufacturers.
Our PowellTechnicians are also Windows Certified.
Windows XP - Windows 10


PartType
: PartType
Irish makes use of a broad range of particles. Many of these particles have the same form but perform different functions.
Ad
: adverbial
This particle is used with an adverb to create an adverbial phrase. It’s most frequent form is go.
Examples
- go minic “often”
- go fóill “yet”
- go dona “badly”
Cmpl
: complementizer
These complementizers are used to introduce a clausal complement. See ccomp.
Examples
- go raibh fhios acu “that they know”
- nach bhfeiceann siad “that they don’t see”
- Is beag nár thit an píosa
Comp
: comparative
The comparative particle is used for introducing a comparative adjective (see Degree).
Examples
- níos mó “bigger”
- níos déine “more intense”
Cop
: copular
The copular particle introduces a copular construction. There is only one instance of this particle in the treebank currently.
Example
- cén fhealsúnacht a ba bhun leis an tuairim “which philosophy that the opinion was based on”
Deg
: degree
The degree particle is used to give a superlative description.
- dá laghad “the least” (at all)
- ba ea a dhéine a bhí sé á breathnú “with how much more handsome he was becoming”
Inf
: infinitive
The particle a is used with a verb stem to form the infinitive in Irish. The verb form is lenited.
Examples
- a cheannach “to buy”
- a thabhairt “to give”
- a dhénamh “to do”
Num
: numeral
The particle used for counting in Irish is a. Most forms stay the same, but those numbers beginning with a vowel such as aon (“one”), or ocht (“eight”) are prefixed by h-.
Examples
- a haon “one”
- a dó “two”
- a seacht “seven”
- a hocht “eight”
Pat
: patronym
This particle is used in last names to mean “son of” or “daughter of”. The masculine forms are Ó and Mac, while the feminine forms include Ní, Nic, Uí and Mhic. Often the anglicised version will use “O” or “Mac” regardless of gender.
Examples
- Mac Craith
- Teaghlach Uí Ghallchóir
- Liz O’ Donnell
- Aire de Valera
Vb
: verbal
Verbal particles include the positive particles a, gur and the negative particle ní. These particles can be used for introducing relative or adverbial clauses, clefts, or for negating the verb.
Examples
- is ann a bhí cónaí ar Cholm “it was there that Colm lived”
- gur thit na caighdeáin “that the standards had fallen”
- ní bheidh sé “he will not”
Voc
: vocative
The vocative particle is a, and is used to directly address someone. In this circumstance, it triggers lenition in the following noun. See Case
Treebank Statistics (UD_Irish)
This feature is language-specific.
It occurs with 10 different values: Ad
, Cmpl
, Comp
, Cop
, Deg
, Inf
, Num
, Pat
, Vb
, Voc
.
860 tokens (6%) have a non-empty value of PartType
.
39 types (1%) occur at least once with a non-empty value of PartType
.
25 lemmas (1%) occur at least once with a non-empty value of PartType
.
The feature is used with 5 part-of-speech tags: ga-pos/PART (841; 6% instances), ga-pos/NOUN (14; 0% instances), ga-pos/ADJ (3; 0% instances), ga-pos/AUX (1; 0% instances), ga-pos/X (1; 0% instances).
PART
841 ga-pos/PART tokens (97% of all PART
tokens) have a non-empty value of PartType
.
The most frequent other feature values with which PART
and PartType
co-occurred: Polarity=EMPTY (743; 88%), PronType=EMPTY (496; 59%).
PART
tokens may have the following values of PartType
:
Ad
(63; 7% of non-emptyPartType
): goCmpl
(105; 12% of non-emptyPartType
): go, nach, nár, náComp
(1; 0% of non-emptyPartType
): níCop
(1; 0% of non-emptyPartType
): aDeg
(1; 0% of non-emptyPartType
): aInf
(160; 19% of non-emptyPartType
): a, do, TrasnaNum
(4; 0% of non-emptyPartType
): aPat
(32; 4% of non-emptyPartType
): Ó, de, Mac, Nic, Ní, UíVb
(464; 55% of non-emptyPartType
): a, d’, ní, nach, gur, do, ar, níor, ná, nárVoc
(10; 1% of non-emptyPartType
): a
| Paradigm a | Cop | Deg | Inf | Num | Vb | Voc |
|---|---|---|---|---|---|---|
| _ | a | a | a | a | ||
| Form=Ecl|PronType=Rel | n-a | |||||
| PronType=Rel | a | a, n-a |
NOUN
14 ga-pos/NOUN tokens (0% of all NOUN
tokens) have a non-empty value of PartType
.
The most frequent other feature values with which NOUN
and PartType
co-occurred: Case=EMPTY (14; 100%), Number=Sing (14; 100%), Form=EMPTY (14; 100%), VerbForm=EMPTY (14; 100%), Definite=EMPTY (14; 100%), Gender=EMPTY (14; 100%).
NOUN
tokens may have the following values of PartType
:
Comp
(14; 100% of non-emptyPartType
): níos
ADJ
3 ga-pos/ADJ tokens (0% of all ADJ
tokens) have a non-empty value of PartType
.
The most frequent other feature values with which ADJ
and PartType
co-occurred: VerbForm=EMPTY (3; 100%), Degree=EMPTY (3; 100%), Case=EMPTY (3; 100%), Number=Sing (2; 67%), Gender=Masc (2; 67%).
ADJ
tokens may have the following values of PartType
:
Voc
(3; 100% of non-emptyPartType
): fáinneach, ghil, uaisle
AUX
1 ga-pos/AUX tokens (0% of all AUX
tokens) have a non-empty value of PartType
.
The most frequent other feature values with which AUX
and PartType
co-occurred: Form=EMPTY (1; 100%), Tense=Past (1; 100%), PronType=EMPTY (1; 100%), VerbForm=Cop (1; 100%), Polarity=EMPTY (1; 100%).
AUX
tokens may have the following values of PartType
:
Comp
(1; 100% of non-emptyPartType
): ba
X
1 ga-pos/X tokens (1% of all X
tokens) have a non-empty value of PartType
.
The most frequent other feature values with which X
and PartType
co-occurred: Abbr=EMPTY (1; 100%), PronType=EMPTY (1; 100%), Dialect=Ulster (1; 100%).
X
tokens may have the following values of PartType
:
Vb
(1; 100% of non-emptyPartType
): cha
Relations with Agreement in PartType
The 10 most frequent relations where parent and child node agree in PartType
:
PART –[conj]–> PART (1; 100%).
PartType in other languages: [da] [ga] [nl] [ro]


Isabel Albir
Work
Résumé
Isabel Albir
UX/UI Designer
THINGS I'VE WORKED ON
Louis Vuitton
Curated Event Responsive Website
Waze
Add a New Feature
Mode de Vie
Editorial Design
Red Bike Studios
E-Commerce
Making Organic Food More Accessible
Wicked Problem
Smart People Inc.
Learning Platform


|
SuanShu, a Java numerical and statistical library | |||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.numericalmethod.suanshu.matrix.doubles.factorization.qr.GramSchmidt
public class GramSchmidt
The Gram–Schmidt process is a method for orthogonalizing a set of vectors in an inner product space. It does so by iteratively computing the vector orthogonal to the subspace spanned by previously found orthogonal vectors.
The orthogonal vector is the difference between a column vector and its projection on the subspace.
There is the problem of "loss of orthogonality" during the process,
which gives arise to the precision error or rounding error.
In general, the bigger the matrix is, e.g., dimension = 3500x3500,
the less precise the results are.
Also, the vectors in Q
may not be as orthogonal.
A numerically stable Gram–Schmidt process with twice re-orthogonalization is implemented to alleviate the problem of rounding errors.
Numerical determination of rank requires a criterion to decide when a value should be treated as zero. This is a practical choice which depends on both the matrix and the application. For instance, for a matrix with a big first eigenvector, we should accordingly decrease the precision to compute the rank.
While the results for the orthogonal basis may match those of the Householder Reflection HouseholderReflection
,
the results for the orthogonal complement may differ because the kernel basis is not unique.
| Field Summary | |
|---|---|
double |
epsilon
a precision parameter: when a number |x| ≤ ε, it is considered 0 |
int |
ncols
number of columns |
int |
nrows
number of rows |
| Constructor Summary | |
|---|---|
GramSchmidt(Matrix A)
Construct an instance of the Gram-Schmidt process to orthogonalize a matrix. |
|
GramSchmidt(Matrix A,
boolean pad0Cols,
double epsilon)
Construct an instance of the Gram-Schmidt process to orthogonalize a matrix. |
| Method Summary | |
|---|---|
PermutationMatrix |
P()
Get a copy of P , the pivoting matrix in the QR decomposition. |
Matrix |
Q()
Get a copy of the orthogonal Q matrix in the QR decomposition. |
UpperTriangularMatrix |
R()
Get a copy of the upper triangular matrix R in the QR decomposition. |
int |
rank()
Get the numerical rank of the matrix A as computed by the QR decomposition. |
Matrix |
squareQ()
Get a copy of the square Q matrix. |
Matrix |
tallR()
Get a copy of the tall R matrix. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
public final int nrows
public final int ncols
public final double epsilon
| Constructor Detail |
|---|
public GramSchmidt(Matrix A, boolean pad0Cols, double epsilon)
A
- the matrix to orthogonalizepad0Cols
- when a column is linearly dependent on the previous columns, there is no orthogonal vector.
We pad the basis
with a 0-vector.epsilon
- a precision parameter: when a number |x| ≤ ε, it is considered 0public GramSchmidt(Matrix A)
A
- a matrix| Method Detail |
|---|
public Matrix Q()
QRDecomposition
Q
matrix in the QR decomposition.
A = QR
Dimension of Q
is nrows x ncols
, same as A
, the matrix to orthogonalize.
Q
in interface QRDecomposition
Q
matrix in the QR decompositionpublic UpperTriangularMatrix R()
QRDecomposition
R
in the QR decomposition.
A = QR
Dimension of R
is ncols x ncols
, a square matrix.
R
in interface QRDecomposition
R
in the QR decompositionpublic PermutationMatrix P()
QRDecomposition
P
, the pivoting matrix in the QR decomposition.
P
in interface QRDecomposition
P
pivoting matrix in the QR decompositionpublic int rank()
QRDecomposition
Get the numerical rank of the matrix A
as computed by the QR decomposition.
Numerical determination of rank requires a criterion to decide when a value should be treated as zero.
This is a practical choice which depends on both the matrix and the application. For instance, for a matrix with a big first eigenvector, we should accordingly decrease the precision to compute the rank.
You may need to change the precision parameter to accurately compute the rank. See the test cases for example.
rank
in interface QRDecomposition
A
public Matrix squareQ()
Q
matrix.
This is an arbitrary orthogonal completion of the Q
matrix in the QR decomposition.
Dimension is nrows x nrows
(square).
A = square_Q %*% tall_R
In this implementation, we extend Q
by adding A
's orthogonal complement at the end.
Suppose Q
has the orthogonal basis for a subspace A
.
To compute the orthogonal complement of A
,
we can apply the Gram-Schmidt procedure to either
I - P = I - Q %*% Q.t()
, or
{u1, u2, ... uk, e1, e2, ... en}
and keeping only the first n
elements of the resulting basis of Rn
.
The last n-k
elements are the basis for the orthogonal complement.
k
is the rank.
We implemented the second option.
squareQ
in interface QRDecomposition
public Matrix tallR()
QRDecomposition
R
matrix.
This is completed by binding zero rows beneath the square upper triangular matrix R
in the QR decomposition.
Dimension is nrows x ncols
. Note that this may no longer be square.
A = square_Q %*% tall_R
tallR
in interface QRDecomposition
R
matrix
|
SuanShu, a Java numerical and statistical library | |||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


This all happened 5 days ago, but it taught me the valuable lesson of setting, emotional stability and their direct relation to the trip.
I went to a party last weekend, and on my way there I managed to pick up 2 grams of mushrooms. I had experimented with them once before alone, and had found it too much of a mindfuck for me when I had nobody to share the millions of thoughts and ideas that came into my head. So, this time I wanted to be more social about it, and I had heard it was going to be a primarily 'shroom and weed' party. Unfortuneately I was wrong.
So we get there, and the host is rolling up a nice fat joint, and I begin the process of chopping up and mixing my mushroom parfait (shrooms and orange juice - I have a really weak stomach when it comes to bad tasting things, and shrooms really make my stomach turn). I down about 1/2 of the bottle, and feel a bit of nausea kick in (I've been told its a reaction between the acid in the juice and the shrooms, but I'm not entirely sure), so I held off on finishing the bottle until I'd had a few tokes. As usual, the nausea went away with Mary Janes kind touch, and I quickly downed the bottle, only to be hit by another wave of nausea. I retired to the washroom to collect myself, drank some water, took a piss, and returned to the party. Everything was going great, I was socializing, smoking weed, listening to music, and the trip was coming on real nice.
Then It really started hitting me. The patterns on the wallpaper were popping out at me, and my friends face seemed disconnected from her body. I told her this and she just laughed at me and said I was startin to feel the trip.
Now, the middle of my trip is a blur of mixed memories.
I remember feeling the best feeling of my life, laying on a couch, listening to music with my eyes half closed and the hundreds of thoughts flying through my brain. I felt like a baby, wrapped in a warm blanket, happy, content. Next, I remember stumbling in on 2 friends who were just starting to fool around, and saying 'hey guys...
This seemed like a fantastic idea to me, and I quickly grabbed my jacket, and walked outside. I wandered into the forest (just outside the house) and onto a long, straight path. I looked down either end and remember thinking that an exciting journey lay at either end. However, I knew what was down one way, so I took the other... all throughout this trip, I had an insanse urge to explore.
I wandered down the path, thinking about life, and coming to all sorts of realizations, many of which I don't remember now, but they were all very detailed, and about specific facets of life. Like why people lie to each other, etc.
I found a leaf, but tore it up because of one of my realizations. And then held that in my mind, for it would be the 'lesson' I learnt from finding the leaf, and would complete the mission I had been sent on.
On the way back to the party, I lost the leaf, forgot the lesson, and barely managed to find my way back. By now I was tripping hard, and couldn't even communicate with anyone. This is where set comes in. I really only knew 2 people at the party, and they were getting friendly in D's car, so I was alone with a bunch of drunk people, while on mushrooms. I was terrified. I couldn't socialize, so people pretty much left me alone, except to try to 'trip' me out, which was the most annoying thing in the world to me.
 Here comes emotional stability. I am generally a very very happy, upbeat person.  Unfortuneately, living with my aunt and uncle, while it wasnt horrible or anything, was a big adjustment. Espescially since I felt like their servant more than their nephew at times, and it sometimes got me really down.
I figured when I took the shrooms that I wasn't too stressed about anything at the moment, so I would have a pleasant experience. So as I pondered life, and my life, I got all sorts of negative realizations about myself. Many of which aren't true, and others that I exxaggerated. I would tell myself that I have no goal in life, that the goals I have are really just lies meant to give me some direction, etc, etc. Being sober now, I realize that it's not true.
I felt completely alone at the party too, because nobody else was experiencing what I saw. I felt like a higher being almost, with all my enlightenment and intelligence I felt the shrooms were giving me.
 I felt that the only way to end the experience was to die, because I thought I would go crazy, literally, before then. I seriously did go insane, to a certain degree. I could feel the high part of my consciousness beating down the rational, sober part, and it was driving me nuts.
Eventually, another friend, M came to the party. I told her right away 'I need to walk and talk', and so she came with me to the store, just to get out. She bought me candy and got me some water, and helped calm me down. We then went back to the party where things got better.
That was the worst part of the trip, the wanting to kill myself, and knowing that nobody else around could understand what I was going through. On top of this, I couldn't go home, because my aunt would clearly have known I was high. And something else mushrooms does to me: I find it extremely difficult to lie. I've heard other people claim the same thing, so I guess it isn't just that I'm an honest guy, haha.
At the party, people realized I had calmed down a little, and so they tried talking to me. I was annoyed at everyone who tried to talk to me, as I felt that they were too stupid to understand anything that I would say, as it was 'too intellectual', and everyone I did try to talk to, misinterpreted everything.
I talked alot of nonsense, and then just got up and wandered out the door in the middle of a convorsation. Then I found myself facing M who offered to drive me home. I told her I couldn't go home yet, it was too early, so we just drove around with some drunk people and got some fast food. I eventually got home, after wandering through a park for 30 minutes as I came down. My aunt was asleep, and it was only 11:30. I had drank the solution at around 7, so I was really only feeling the body high.
I eventually went to sleep and woke up the next morning feeling fairly miserable.
Looking back on THIS experience, I think I learnt a valuable lesson. It was the first bad trip I had ever had, and I definitely do not want to repeat the process again. Mushrooms appear to be too much of a head trip for me, and I mostly took them for the visuals. I think I will stick to mdma and weed for a while, but I haven't counted myself out of the mushroom game yet. I won't ever do them in a situation like that again however, and next time will be with good friends who are on the same substance.
mushrooms are an amazing drug, I think too amazing for me. I used to want to try LSD, but after the longevity of the mushrooms, I think it would be too much for me to be high for 12 hours. I still question the point of my life, and wonder if I'm not just lying to my sober self about everything. I know its from the bad trip, and if I could go back in time, I would have just bought some nice bud. Good luck, and safe tripping.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Tic-Tac-Toe
How To Play
- You play on a 3 by 3 grid, and there is two players.
- Each player is either O's or X's
- The players take turns placing their players (X's or O's) in one of the grid squares
- This goes on until all the grid squares are filled or if one player gets three in a row
- The winner is whoever gets three in a row first
- If noone gets three in a row then it ends in a tie
- Interesting note: If you start first there is a way you can always win
Last edited March 24, 2018 by Kody Rogers


{{'PAYMENT_MANAGEMENT_PAGE.FIXED_HEADER' | translate}}
{{playerPayment.player.alias}}
{{playerPayment.payment.name}}
{{playerPayment.payment.amount}} €
{{'PAYMENT_MANAGEMENT_PAGE.NO_FIXED_HEADER' | translate}}
{{playerPayment.player.alias}}
{{playerPayment.payment.name}}
{{playerPayment.payment.amount}} €


Hi, I’m Sai Sumanth Talluri, a computer science enthusiast and Cynophile, and this is my website. I live in Hyderabad and have a great dog named Snoopy.
Originally from Hyderabad, I’m studying at SRM University in Chennai, TamilNadu.
Apart from coding I'm Interested in


Interface GoogleMapsInterface
Interface for GoogleMaps class
Direct known implementers
Namespace: Google\GoogleMaps
Package: Google\GoogleMaps
License: http://opensource.org/licenses/MIT
Author: DeeJRoth<EMAIL_ADDRESS>Todo: Change how Image Attributes are set (Breakup some of the spaghetti!)
Todo: Change some of the parameters to use array type
Located at Google/GoogleMaps/GoogleMapsInterface.php
Package: Google\GoogleMaps
License: http://opensource.org/licenses/MIT
Author: DeeJRoth<EMAIL_ADDRESS>Todo: Change how Image Attributes are set (Breakup some of the spaghetti!)
Todo: Change some of the parameters to use array type
Located at Google/GoogleMaps/GoogleMapsInterface.php
Methods summary
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|


Preparation time
30 mins to 1 hour
Cooking time
1 to 2 hours
Serves
Serves 6
Crème de cassis adds a grown-up touch to this school dinner favourite.
Equipment and preparation: You will need six 6cm/2in pudding moulds.
For the spotted dick, grease six 6cm/2in pudding moulds with the melted butter.
Place the sultanas and currants in a small saucepan and add the rum. Bring to the boil, then turn off the heat and leave to stand for 30 minutes.
Meanwhile, place the flour, baking powder, suet, sugar and lemon zest in a large bowl and mix.
Add the rum-soaked fruit and the milk and stir until you have a soft dough.
Fill each mould three-quarters full. Cut out six squares of aluminium foil large enough to cover the pudding moulds generously. Fold a pleat down the centre of each square (to allow the puddings to rise) and cover the moulds. Secure the foil with cook's string.
Place a small heatproof plate in the bottom of a large saucepan and sit the moulds on top. Pour in enough boiling water to reach half way up the sides of the moulds. Place over a medium heat, place a lid on top and cook for an hour. Top up the pan with more boiling water if it looks like it might dry out.
Meanwhile, make the custard. Put the cream, milk and vanilla seeds in a large saucepan and warm gently.
In a separate bowl, whisk the egg yolks and sugar until light and frothy. Gradually add the warm milk mixture to the bowl, whisking all the time. Once incorporated, pour back into the pan and, stirring all the time, heat until thick enough to coat the back of a spoon.
For the blackberry sauce, pour the crème de cassis into a medium saucepan and add the sugar and blackberries. Heat for five minutes then pass through a sieve. Keep the liquid and discard the fruit.
To serve, carefully decant the puddings and place in serving bowls. Pour the custard around the pudding and drizzle a little of the blackberry sauce over.


Next: Agreement on Parameter Specializers and Qualifiers, Previous: Introduction to Generic Functions, Up: Generic Functions and Methods
Methods define the class-specific or identity-specific behavior and operations of a generic function.
A method object is associated with code that implements the method’s behavior, a sequence of parameter specializers that specify when the given method is applicable, a lambda list, and a sequence of qualifiers that are used by the method combination facility to distinguish among methods.
A method object is not a function and cannot be invoked as a function. Various mechanisms in the object system take a method object and invoke its method function, as is the case when a generic function is invoked. When this occurs it is said that the method is invoked or called.
A method-defining form contains the code that is to be run when the arguments to the generic function cause the method that it defines to be invoked. When a method-defining form is evaluated, a method object is created and one of four actions is taken:
If a generic function of the given name already exists and if a method object already exists that agrees with the new one on parameter specializers and qualifiers, the new method object replaces the old one. For a definition of one method agreeing with another on parameter specializers and qualifiers, see Agreement on Parameter Specializers and Qualifiers.
If a generic function of the given name already exists and if there is no method object that agrees with the new one on parameter specializers and qualifiers, the existing generic function object is modified to contain the new method object.
If the given name names an ordinary function, a macro, or a special operator, an error is signaled.
Otherwise a generic function is created with the method specified by the method-defining form.
If the lambda list of a new method is not congruent with the lambda list of the generic function, an error is signaled. If a method-defining operator that cannot specify generic function options creates a new generic function, a lambda list for that generic function is derived from the lambda list of the method in the method-defining form in such a way as to be congruent with it. For a discussion of congruence , see Congruent Lambda-lists for all Methods of a Generic Function.
Each method has a specialized lambda list, which determines when that method can be applied. A specialized lambda list is like an ordinary lambda list except that a specialized parameter may occur instead of the name of a required parameter. A specialized parameter is a list (variable-name parameter-specializer-name), where parameter-specializer-name is one of the following:
denotes a parameter specializer which is the class named by that symbol.
denotes a parameter specializer which is the class itself.
denotes a parameter specializer which satisfies the type specifier (eql object), where object is the result of evaluating form. The form form is evaluated in the lexical environment in which the method-defining form is evaluated. Note that form is evaluated only once, at the time the method is defined, not each time the generic function is called.
Parameter specializer names are used in macros intended as the user-level interface (defmethod), while parameter specializers are used in the functional interface.
Only required parameters may be specialized, and there must be a parameter specializer for each required parameter. For notational simplicity, if some required parameter in a specialized lambda list in a method-defining form is simply a variable name, its parameter specializer defaults to the class t.
Given a generic function and a set of arguments, an applicable method is a method for that generic function whose parameter specializers are satisfied by their corresponding arguments. The following definition specifies what it means for a method to be applicable and for an argument to satisfy a parameter specializer.
Let < A_1, ..., A_n> be the required arguments to a generic function in order. Let < P_1, ..., P_n> be the parameter specializers corresponding to the required parameters of the method M in order. The method M is applicable when each A_i is of the type specified by the type specifier P_i. Because every valid parameter specializer is also a valid type specifier, the function typep can be used during method selection to determine whether an argument satisfies a parameter specializer.
A method all of whose parameter specializers are the class t is called a default method ; it is always applicable but may be shadowed by a more specific method.
Methods can have qualifiers, which give the method combination procedure a way to distinguish among methods. A method that has one or more qualifiers is called a qualified method. A method with no qualifiers is called an unqualified method. A qualifier is any non-list. The qualifiers defined by the standardized method combination types are symbols.
In this specification, the terms "primary method" and "auxiliary method" are used to partition methods within a method combination type according to their intended use. In standard method combination, primary methods are unqualified methods and auxiliary methods are methods with a single qualifier that is one of :around, :before, or :after. Methods with these qualifiers are called around methods, before methods, and after methods, respectively. When a method combination type is defined using the short form of define-method-combination, primary methods are methods qualified with the name of the type of method combination, and auxiliary methods have the qualifier :around. Thus the terms "primary method" and "auxiliary method" have only a relative definition within a given method combination type.


If the browser supports Promises then you will see "Yes, that's true!" down below.
If the browser doesn't support Promises then you will see "No, that's not true!" down below.


| DOSE: |
10 hits |
smoked |
Cannabis |
(plant material) |
I had smoked a little bit of a spliff before but it never did anything for me. I met this girl and we became freinds through her girlfreind and we were just hanging out at her flat and another freind said he could get her some skunk.
So we (my freind, her girlfreind & the freind who got the draw) all had some and she let me try using different types of bongs. I took a couple of tokes from at least 3 different bongs, and I didn't feel any different. Then she handed me this little blue pipe so I had a toke of that. It hurt my throat abit so I went to get a glass of water to soothe it. I felt abit dizzy when I got up then sat down on a bean bag facing my three freinds sitting on the sofa.
That's when it hit me. All of a sudden I couldn't stop smiling. I felt like there were two pieces of string attatched to my cheeks and they were pulling them. Once I realized this I found it so funny, I couldn't stop laughing. My freinds were all amazed, one finding it hilarious, another covering her face with a blanket to conceal her laughter while the other didn't find it funny and just stared at me. I felt paranoid about this but I knew weed makes you feel that way so I just said to myself it was the weed's fault.
I then started seeing things. The walls were moving backwards and forwards (as were my freinds on the sofa) and eveything appeared to be like a painting, with vivid colours and marks. I then could see an audience in the kitchen from where I was sitting, like it was part of a circus or somrthing.
 All I was doing was vocalising what I could see/hear/feel yet I was getting on their nerves. My freind's face kept on changing, like her hairstyle and skin tone, and she looked so cute. If I listened to her girlfreind talk for too long she started to sound like a baby, all gurgling and stuff.
I then decided to pour myself some drink and concentrated very hard on not spilling it. I then remembered how my freind had said she'd concentrated very hard when driving and immedeatley I told her like it was the most amazing thing in the world. I said the drink was like an elevator going up the cup. Fucked up or what?
We then sat and talked for abit. I then heard the chorus from 'wannabe' by the spice girls repeat itself on what seemed like a wheel behind me to my right and as ever shouted out what I'd heard, much to my freind's amusement. 'Your'e hearing things?'
I then became quite hungry and made myself a hot chocolate with cream sprayed on top. It tasted amazing, so I passed it to my freind who said it tasted awful. Then I had a little kinder bueno chocolate. It tasted amazing, so intense, as did the chunk of yorkie I had after. While all this was happening I was writing it all down, which is why I remember everything. I then made up a song called 'Monument in yourself' and started singing it. All this was accompanied by fits of laughter, good feeling etc.
We then lay down to sleep, with my 2 freinds laying down together and me further down staring straight into the heater. The patterns on it looked like 'diamonds' and we were listening to 'all that she wants' by ace of base. I can only describe what I felt as entering heaven, it felt so amazing, one word I never stopped using while stoned and christened it my 'word of the year'.
The next day I got up and felt normal. My freind asked if I wanted another toke so I did and the moment I rose it hit me. All the feelings and thoughts I'd felt while stoned the night before where present again, and I went to have a shower as planned.
To begin with I couldn't stop laughing, loudly. Then I just felt like I was under a waterfall in a tropical place. It was the best shower I've ever had. I then went home and felt abit deluded, but ok there was nothing bad about the experience.
At first, when I did my first tokes the previous night I did feel a little afraid because I'd never felt that way. But once I got used to it I felt great. I also felt as if the skunk had clogged up in my throat and I had to spit it out, but nothing major.
My freind said she'd never seen someone so stoned on their first try and someone so funny, which makes me happy that I made her laugh, but since then I haven't OD'd quite the way I did my first time.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Install
Please enter the values you wish to have for this application.
Host IP / Name
Database Name
Database Username
Database Password