The SWL thread system extends Chez Scheme to provide explicit concurrency to both SWL and its applications. A variety of user interface problems are elegantly solved by providing both the SWL implementer and the SWL application writer with access to multiple independent threads of control. Judicious use of multiple threads improves the modularity of both SWL and many of its applications.
Chez Scheme provides a sufficient basis for implementing a thread system entirely in Scheme. The Chez Scheme notions of interrupt handling and timed preemption provide a mechanism for interrupting execution of a Scheme program in a controlled way.
Scheme's general purpose control primitive call-with-current-continuation (call/cc) provides a means for defining new dynamic execution contexts, or continuations, and for the transfer of control from one continuation to another. When augmented with appropriate additional information, a Scheme continuation becomes a thread, or independently schedulable continuation. The SWL thread system provides for the creation and destruction, suspension and resumption, synchronization, and inspection of multiple threads of control.
The major design goals for the thread system are summarized here:
While these goals have largely been achieved, we note two significant exceptions now. First, the Chez Scheme syntactic form fluid-let does not function with multiple threads as might be expected. Second, to achieve the other goals we have tolerated some dependence on Chez Scheme internals, i.e., the use of certain undocumented Chez Scheme system mode primitives. These issues are fully discussed below.
The rest of this chapter is a user's guide to the SWL thread system. The the thread system adds a number of API procedures and syntax, data stuctures, and global variables. Separate sections discuss the effects on standard language constructs and dependencies on Chez Scheme internals.
The thread system adds a number of user interface procedures to Chez Scheme.
ps returns a list of values, one for each thread of the current thread group, where each value provides information about the thread. A value is a list of atoms (strings, symbols, or numbers), or sublists of two elements: a keyword symbol and an atom. The argument thread specifies which thread's values are returned. If omitted, thread defaults to the currently running thread.
The output of ps is intended for use as input to an interpreting procedure, such as pps.
ps-all returns a list of values, one for each thread in the system, where each value provides "raw" information describing the thread. See ps above for more details.
The output of ps-all is intended for use as input to an interpreting procedure, such as pps.
pps (short for "pretty ps") prints a status report for all threads. output-port determines where the report is printed. If omitted, it defaults the value of (current-output-port).
> (pps)
(run-queue 10 4) (sleep-queue)
Thread Attributes
------ ----------
[console(1)] app-q 0.01 server (starts 8)
[Fallback(2)] idle (priority -1) 0.01 server (starts 4)
[System Fallback(3)] idle (priority -1) 0.01 server (starts 1)
[Event Dispatcher(4)] ready (lowest priority) 0.01 server (starts 2499)
[Fallback(7)] idle (priority -1) 0.01 server (starts 998)
[Repl(9)] running 0.01 server (starts 9)
[10] (sleeping 0.099) 0.01 (starts 14)
>
In this example pps-all has been executed in a freshly started SWL system. The output shows that at present there are seven threads in total, which are clustered into four thread groups. The first group provides support for the conventional Chez Scheme command line interpreter. The second and third (single-thread) groups are internal to SWL. The forth group (of three threads) is allocated to the initial REPL, which is automatically created when SWL is started.
A thread attribute is either an atom or a list containing a keyword and a value. Certain attributes are optional may not appear for a given thread. The possible attributes are:
ps-num returns the number of threads currently in the system. The number of threads is affected by thread creation (via thread-fork and thread-fork-group) and by thread termination (via thread-kill).
thread->k returns the Scheme continuation of its thread argument. If the currently executing thread is passed, the return value is the continuation of the currently executing thread when it was last started.
thread-number returns the integer identifier of the argument thread, or the currently executing thread if no argument is supplied.
thread-self returns the currently executing thread. In the thread system, all Scheme code is executed within an associated thread.
thread-quantum-remaining returns the amount of execution time remaining before the currently executing thread is subject to preemption by the thread scheduler. The time quantum is a positive real number, typically a small fraction of a second, e.g., .01 second.
If the currently executing thread's time quantum has expired, and another thread of equal or higher priority is ready to run, the thread scheduler suspends the current thread (i.e., forces the thread to yield), and starts another one.
thread-find returns the thread corresponding to the integer identifier argument. If no such thread exists, thread-find returns #f.
procedure: (thread-become-server!)
returns: unspecified
Exceptions are execution events that alter the normal flow of control within a thread. There are several kinds of thread system exceptions: interrupts, resets, and errors. Different kinds of threads may handle these exceptions in different ways. One kind of thread that is frequently used in SWL is called a server. A server is a thread that:
Typically, a server handles an exception by resuming its wait for more input. Examples of server threads are event loops and read-eval-print-loops.
thread-become-server! accepts a reset handler and a thread as optional arguments. The thread's interrupt-handler and reset-handler parameters, which by default are per-group, are changed to per-thread. The thread's interrupt handler is set to invoke the reset handler. The thread's reset handler is set to the handler argument if one is supplied, or else is set to issue a warning message and suspend the thread. Finally, the thread is added to the thread group's list of servers.
Exactly one thread in the system is distinguished as the console thread. The console thread is interrupted in response to a Chez Scheme keyboard or Unix process interrupt event. If the optional argument is omitted, the currently running thread becomes the console. thread-become-console! calls thread-become-server!, passing a reset handler that will abort the system if it is called. It is the responsibility of the console thread to install a different reset handler in order to avoid this possibility. This happens automatically if the console thread subsequently starts a new cafe.
thread-break interrupts a thread's normal execution and arranges for an interrupt procedure to be called within the interrupted thread's dynamic execution context. If the interrupt procedure returns normally, the interrupted thread's normal execution will resume. thread-break permits one thread to side-effect another thread's parameter values, or to alter its flow of control.
With no arguments, thread-break interrupts the currently running thread, otherwise the specified thread is interrupted. If reason is supplied, and is not #f, an exception information block is created and stored in the thread-exception (per-thread) and last-exception (global) parameters for the interrupted thread. If thunk is supplied, it is called by the interrupted thread, otherwise that thread's interrupt-handler is called. If run-now? is supplied, the interrupting thread is suspended and the interrupted thread is restarted at highest priority so that the interrupt procedure is run immediately. In this case the interrupting thread is scheduled to resume immediately following the interrupted thread.
thread-debug calls the Chez Scheme debugger. The continuation stored in thread-exception (which belongs to the currently running thread) is inspected, if it exists. Otherwise, the continuation stored in last-exception (which belongs to another thread) is inspected, if it exists. Otherwise a warning message is issued that nothing may be inspected.
A procedure called by the error primitive in response to a thread execution error, which prints error data and thread-identifying information to the console output port.
A thread is a schedulable continuation. thread-fork converts thunk into a new ready-to-run thread in the current thread's group. quantum is the amount of time in milliseconds that the thread may run before it is preempted by the scheduler. If quantum is omitted, it defaults to the value of the parameter thread-default-quantum. priority determines when a thread will be executed when multiple threads are ready to run. A higher priority thread always runs before a lower one. If omitted, priority defaults to the priority of assigned to the caller's thread group.
A thread group is a collection of threads that share a single set of extended parameter group locations. thread-fork-group converts thunk into a new ready-to-run thread in a new group. quantum is the amount time in seconds that the thread may run before it is preempted by the scheduler. If quantum is omitted, it defaults to the value of the parameter thread-default-quantum. priority determines when a thread will be executed when multiple threads are ready to run. A higher priority thread always runs before a lower one. If omitted, priority defaults to the priority of assigned to the caller's thread group. params is a vector of thread group parameter values to be copied into the new group's parameters. If omitted, params defaults to the vector of parameter values assigned to the caller's thread group.
thread-kill terminates the specified thread. num specifies the integer identifier of the thread to be killed. If omitted, the currently running thread is killed.
It is an error to kill the last runnable thread.
A message queue is an object that enables thread synchronization and the exchange of data between cooperating threads. thread-make-msg-queue creates a new empty message queue. name is a datum (typically a Scheme symbol) that denotes the queue.
thread-msg-waiting? returns a #t if one or more messages have been placed on the queue (by a call to thread-send-msg). Otherwise, it returns #f.
If a message is waiting on queue, thread-receive-msg immediately returns the message, otherwise it enqueues the thread on the queue, which blocks it from running until another thread sends a message to the queue.
thread-receiver-waiting? returns #t if a thread is blocked on the queue awaiting a message. Otherwise, it returns #f.
If a receiver thread is waiting on queue, thread-send-msg immediately delivers msg to the thread, causing it to be rescheduled as ready-to-run, otherwise it enqueues the message on the queue and immediately returns. If mode is supplied it must be the symbol urgent. Urgent mode causes the message receiver, if any, to be immediately awakened and run at highest priority. The sending thread yields at highest priority, so that it will immediately follow the receiver when that thread next yields.
thread-reschedule moves previously enqueued thread to a new position within its queue, based on priority, an integer value.
thread-sleep suspends the currently running thread for msecs milliseconds, by placing it on the sleep queue.
thread-wake awakens thread by removing it from the sleep queue and placing it on the run queue.
thread-yield suspends the currently running thread, forcing it to relinquish control to another runnable thread. The current thread's scheduling priority is reset to the priority of its group (see thread-reschedule), and the thread is placed in the run-queue according to its (new) priority.
The return value of thread-yield is used internally by the thread system (by the message queue primitives), and should be ignored by user code.
procedure: (thread-highest-priority)
returns: see explanation
thread-highest-priority returns a negative fixnum value that denotes the highest priority at which a thread may be scheduled to run. (Larger numbers represent lower priorities.)
thread-lowest-priority returns a positive fixnum value that denotes the lowest priority at which a thread may be scheduled to run. (Larger numbers represent lower priorities.)
In standard Chez Scheme a parameter is a procedure that encapsulates a single location. The thread system enhances standard parameters to permit individual threads and thread groups to possess distinct, private locations, or to access a single, global location. A extended parameter is a procedure that manages access to the various assignment locations associated with the parameter.
value and filter are as for standard parameters. value is assigned to the extended parameter's global location.
global variable: thread-timer-interrupt-hook
thread-timer-interrupt-hook is assigned a thunk that is called once for each interrupt taken by the Chez Scheme timer interrupt. Since the thread system triggers the timer interrupt at a very high frequency, it is essential that the timer interrupt hook procedure be made as simple as possible.
thread-run-queue-idle? is #t if one or more threads are ready to run, #f otherwise.
thread-sleep-queue-idle? is #t is one or more threads are sleeping, i.e., blocked on the sleep queue, #f otherwise.
thread-conout is the standard Chez Scheme console output port.
procedure: (error)
returns: unspecified
error invokes the thread's error handler. Then, if the thread is not a server, error suspends the thread. Otherwise, error calls reset.
If a currently running thread is not a server, reset issues a warning and returns. Otherwise, it invokes the thread's reset-handler, as in standard Chez Scheme.
new-cafe starts a new Chez Scheme cafe in the currently executing thread group. The thread system supports multiple concurrently executing cafes.
Chez Scheme extends the standard Scheme top-level environment with additional global variables. To provide disciplined access to these system variables, each variable is assigned an interface procedure called a parameter. In standard Chez Scheme, a parameter encapsulates a single location, which stores the value of the parameter.
With multiple threads, parameter locations should often be made private to individual threads, or to thread groups. In the thread system, most Chez Scheme system parameters are reimplemented to provide distinct storage locations for different threads. Parameters with more than one storage location are called extended parameters. In addition to per-thread and per-group locations, each extended parameter retains a single location that is global to all threads. A parameter's location is either private to the thread, or it may be delegated to the thread's group location or to the global location. Location delegation is determined per-thread based on the assignment mode. The default assignment mode uses the group location.
Extended parameters require additional operations and arguments. With zero or one argument, an extended parameter behaves like a standard parameter, except that the accessed location may be local to the thread or group. For clarity, in this section a parameter call with zero or one argument is labeled a standard parameter operation. When called with exactly two arguments, an extended parameter performs an extended operation. The first argument of a two-argument parameter call is the operation and the second argument is the value:
extended parameter: (<parameter> operation value)
returns: see below
For certain extended parameter operations, the value argument is unused, however an argument must still be supplied. The unused argument is a placeholder that provides the number of arguments needed to distinguish extended (two-argument) parameter operations from standard (zero or one argument) ones. The extended operations are as follows:
The thread system adds several standard and extended parameters to the Scheme top-level environment.
parameter: (keyboard-interrupt-handler)
returns: see explanation
The thread system replaces the Chez Scheme keyboard-interrupt-handler. Hence, this handler must not be changed by the user.
The thread system replaces the Chez Scheme timer-interrupt-handler. Hence, this handler must not be changed by the user.
parameter: (thread-default-quantum)
parameter: (thread-default-quantum quantum)
returns: an integer
thread-default-quantum is the default execution time quantum in milliseconds that is assigned when a thread is scheduled for execution.
thread-default-ticks is the number of Chez Scheme timer ticks that must elapse before a timer interrupt occurs, thus determining the frequency of timer interrupts.
Higher interrupt frequencies increase both the timing accuracy of the preemptive scheduling algorithm and overhead caused by preemptive scheduling. The default value was selected to give good performance under most conditions.
extended parameter: (cafe-level)
extended parameter: (cafe-level level)
returns: see explanation
SWL enables multiple user interaction environments (read-eval-print loops) to be active concurrently. The Chez Scheme cafe procedure implements one such user environment. In SWL, multiple cafes may be active concurrently, each running in a separate thread group.
cafe-level determines the cafe nesting level of a single Chez Scheme cafe. Hence, one cafe-level parameter location is allocated for each thread group.
interrupt-handler provides each thread with an interrupt thunk.
An executing thread may forcibly alter another thread's normal flow of control by interrupting it via a call to thread-break. thread-break takes an optional argument, an interrupt thunk. If no argument is supplied, the interrupt thunk is taken from the thread's interrupt handler.
When the interrupted thread is next started, control is transferred to the interrupt thunk. If the interrupt thunk returns normally, control is then transferred to the interrupted thread's original continuation.
 Kinds of exceptions are errors and interrupts. The exception data structure stores the thread's continuation and other data about the exception. The continuation is available for inspection.
A server is a thread that is designed to handle events or process transactions indefinitely. Kinds of servers are read-eval-print loops and SWL event loops. Under normal circumstances a server thread does not terminate, even when an error exception occurs.
(thread-group-servers) returns a list of all the threads in the current thread's group that are servers.
(thread-name) returns the name assigned to the thread, a Scheme string. The default name is the empty string.
Each thread is assigned an execution priority, a Scheme fixnum integer. The most negative fixnum is the highest priority value. Higher priority threads always execute ahead of lower priority ones.
(thread-quantum) returns the thread's priority.
Each thread is assigned an execution time quantum, specified in seconds. The quantum determines how much CPU time a thread is permitted to consume before it is preempted (i.e., forced to yield in favor of another runnable thread). A typical quantum is ten milliseconds.
(thread-quantum) returns the run-time allotted when the thread is scheduled to run.
A thread context switch does not invoke continuation winders. Hence, the effects of dynamic-wind, fluid-let, and parameterize are not undone when a thread yields control to another thread.
Many Chez Scheme parameters are maintained on a per-thread basis, however, and the values of such threaded parameters are changed with each context switch. Finally, the Chez Scheme interrupt counter, which is affected by the Chez Scheme primitives enable-interrupts, disable-interrupts, and critical-section, is also maintained on a per-thread basis. Thus, for example, a thread yield that occurs within the context of a critical-section effectively cancels the critical-section (and re-enables interrupts) until the invoking thread is restarted.


tpool - Part of the Tcl threading extension implementing pools of worker threads.
This package creates and manages pools of worker threads. It allows you to post jobs to worker threads and wait for their completion. The threadpool implementation is Tcl event-loop aware. That means that any time a caller is forced to wait for an event (job being completed or a worker thread becoming idle or initialized), the implementation will enter the event loop and allow for servicing of other pending file or timer (or any other supported) events.
This command creates new threadpool. It accepts several options as key-value pairs. Options are used to tune some threadpool parameters. The command returns the ID of the newly created threadpool.
Following options are supported:
This command returns a list of IDs of threadpools created with the tpool::create command. If no threadpools were found, the command will return empty list.
This command sends a script to the target tpool threadpool for execution. The script will be executed in the first available idle worker thread. If there are no idle worker threads available, the command will create new one, enter the event loop and service events until the newly created thread is initialized. If the current number of worker threads is equal to the maximum number of worker threads, as defined during the threadpool creation, the command will enter the event loop and service events while waiting for one of the worker threads to become idle. If the optional ?-nowait? argument is given, the command will not wait for one idle worker. It will just place the job in the pool's job queue and return immediately.
The command returns the ID of the posted job. This ID is used for subsequent tpool::wait, tpool::get and tpool::cancel commands to wait for and retrieve result of the posted script, or cancel the posted job respectively. If the optional ?-detached? argument is specified, the command will post a detached job. A detached job can not be cancelled or waited upon and is not identified by the job ID.
If the threadpool tpool is not found in the list of active thread pools, the command will throw error. The error will also be triggered if the newly created worker thread fails to initialize.
This command waits for one or many jobs, whose job IDs are given in the joblist to get processed by the worker thread(s). If none of the specified jobs are ready, the command will enter the event loop, service events and wait for the first job to get ready.
The command returns the list of completed job IDs. If the optional variable ?varname? is given, it will be set to the list of jobs in the joblist which are still pending. If the threadpool tpool is not found in the list of active thread pools, the command will throw error.
This command cancels the previously posted jobs given by the joblist to the pool tpool. Job cancellation succeeds only for job still waiting to be processed. If the job is already being executed by one of the worker threads, the job will not be cancelled. The command returns the list of cancelled job IDs. If the optional variable ?varname? is given, it will be set to the list of jobs in the joblist which were not cancelled. If the threadpool tpool is not found in the list of active thread pools, the command will throw error.
This command retrieves the result of the previously posted job. Only results of jobs waited upon with the tpool::wait command can be retrieved. If the execution of the script resulted in error, the command will throw the error and update the errorInfo and errorCode variables correspondingly. If the pool tpool is not found in the list of threadpools, the command will throw error. If the job job is not ready for retrieval, because it is currently being executed by the worker thread, the command will throw error.
Each call to this command increments the reference counter of the threadpool tpool by one (1). Command returns the value of the reference counter after the increment. By incrementing the reference counter, the caller signalizes that he/she wishes to use the resource for a longer period of time.
Each call to this command decrements the reference counter of the threadpool tpool by one (1).Command returns the value of the reference counter after the decrement. When the reference counter reaches zero (0), the threadpool tpool is marked for termination. You should not reference the threadpool after the tpool::release command returns zero. The tpool handle goes out of scope and should not be used any more. Any following reference to the same threadpool handle will result in Tcl error.
Suspends processing work on this queue. All pool workers are paused but additional work can be added to the pool. Note that adding the additional work will not increase the number of workers dynamically as the pool processing is suspended. Number of workers is maintained to the count that was found prior suspending worker activity. If you need to assure certain number of worker threads, use the minworkers option of the tpool::create command.
Resume processing work on this queue. All paused (suspended) workers are free to get work from the pool. Note that resuming pool operation will just let already created workers to proceed. It will not create additional worker threads to handle the work posted to the pool's work queue.
Threadpool is one of the most common threading paradigm when it comes to server applications handling a large number of relatively small tasks. A very simplistic model for building a server application would be to create a new thread each time a request arrives and service the request in the new thread. One of the disadvantages of this approach is that the overhead of creating a new thread for each request is significant; a server that created a new thread for each request would spend more time and consume more system resources in creating and destroying threads than in processing actual user requests. In addition to the overhead of creating and destroying threads, active threads consume system resources. Creating too many threads can cause the system to run out of memory or trash due to excessive memory consumption.
A thread pool offers a solution to both the problem of thread life-cycle overhead and the problem of resource trashing. By reusing threads for multiple tasks, the thread-creation overhead is spread over many tasks. As a bonus, because the thread already exists when a request arrives, the delay introduced by thread creation is eliminated. Thus, the request can be serviced immediately. Furthermore, by properly tuning the number of threads in the thread pool, resource thrashing may also be eliminated by forcing any request to wait until a thread is available to process it.
thread, tsv, ttrace
thread, threadpool


See original publication at https://correctiv.org/superbugs
This example demonstrates how to use d3-playbooks-maps
to render multiple responsive static maps efficiently. See README
for details.
The datasource is a single Google Spreadsheet loaded via load-spreadsheet.js
.
The color/data scaling is the same for each map to make them comparable.
This shows how to manipulate the rendered maps once they are created, for example change colors afterwards. It's also explained in the README
how to do that.
Click on one of the buttons to update the colorScheme
. The schemes are all from d3-scale-chromatic
. I personally recommend the RANDOM
-button.


Gists
Name
Language
Actions
{% for gist in gists: %}
{{ gist.title }}
{{ gist.lang }}
View
Edit
{% endfor %}
Return home
Create new gist


Your browser doesn't appear to support the
<canvas>
element.
Loading...
0%
Cannot initialize WebGL context.
fullscreen
fullscreen_exit
3D Buddha Live Wallpaper


You are currently:
To change your status, click File -> Work Offline. In supporting browsers ,the change is detected via events and the status above should change.


Enzo output format
Although there are a number of ways of specifying when (and how often)
enzo outputs information, there is only one type of output 'dump' (well,
not quite -- there are now movie dumps, see below), which can also be used
to restart the simulation. The output format uses the following files,
each of which begins with the output name, here we use the example base_name,
and are then followed by the output number, ranging from 0000 to 9999 (if
more than 10000 grids are generated then the number goes to 10000, etc.).
When restarting, or other times when an output filename needs to be specified,
use the name without any extension (e.g. enzo -r base_name0000).
-
base_name0000 - This ascii file contains a complete listing of all
the parameter settings, both those specified in the initial parameter file,
as well as all those for which default values were assumed. The parameters
(see the section on parameters for a discussion)
are in the same format as that used in the input file: parameter_name
= value. This file is modifiable if you would like to restart from
a certain point with different parameter values.
-
base_name0000.hierarchy - This ascii file specifies the hierarchy
structure as well as the names of the grid files, their sizes, and what
they contain. It should not be modified and was not intended for general
human consumption.
-
base_name0000.grid0001 - The field information for each grid is
contain in separate files, one for each grid, numbering from 0001 to 9999.
The format is the Hierarchy Data Format (HDF), a self-describing machine-independent
data format developed and supported by the National Center for Supercomputing
Applications (NCSA). More information can be found on their home
page. Many scientific visualization packages support this format, including
IDL, AVS, IBM data explorer, xmgr, VFleet and viewit. Each field is stored
as it's own one-, two- or three-dimensional Scientific Data Set (SDS),
and is named for identification. Particles (if any) are included
with a set of one-dimensional SDS's.
-
base_name0000.boundary - An ascii file which specifies boundary
information. It is not generally useful to modify.
-
base_name0000.boundary.hdf - Contains field-specific boundary information,
in HDF format.
-
base_name0000.radiation - This ascii file is only generated if using
the self-consistent radiation field.
Output units
The units of the physical quantities in the grid SDS's are depend on the
problem being run. For most test problems there is no physical length
or time specified, so they can be be simply scaled. For cosmology
there are a set of units designed to make most quantities of order unity
(so single precision variables can be used). These units are defined
below (rho0 = 3*OmegaMatterNow*(100*HubbleConstantNow km/s/Mpc)^2/(8*Pi*G)).
-
length: ComovingBoxSize/HubbleConstantNow * Mpc / (1+z)
-
density: rho0 * (1+z)^3
-
time: 1/sqrt(4*Pi*G*rho0*(1+InitialRedshift)^3)
-
temperature: K
-
velocity: (length/time)*(1+z)/(1+InitialRedshift) (this is z independent)
[This was corrected April 21/99 -- thanks to Chris Loken for pointing this
out].
The conversion factor is also given in the ascii output file (base_name0000):
search for DataCGSConversionFactor. Each field has its own conversation
factor, which converts that field to cgs units.
Movie Dumps
There is now a (somewhat experimental) "movie" output. In fact, this
does not generate images per se (because of the difficulty in following
the multiple scales), but does output data that can be used to generate
movies. The data is a shortened version of the full output and is
intended to be compact, simple and fast. It cannot be used as a restart
file.
If movie dumps are requested (i.e. the parameter dtMovieDump is non-zero),
then for each "movie" step, each processor generates 3 files (4 if star
particles are being used):
MovieDataNNNNNN.gridP
MovieDataNNNNNN.dmP
MovieDataNNNNNN.starP
MovieDataNNNNNN.summaryP
Where NNNNNN (zero padded with at least six digits) is the number of
the little (movie) step and P is the processor number (not zero padded).
Example: MovieData000001.summary0. The summary file contains the
number of particles and additional information in ascii format.
Thus there is a total of 4*Nproc*Nstep files (Nproc is the number of processors
that enzo is being run with).
Each of the grid, dm and star files contain a series of entries for
each "point" (whether it be a grid zone or particle):
x, y, z, density, dx, [...]
where each value is a 4 byte float and [...] indicates other information
specific to that kind of point (right now I have
temperature & metallicity for grid points and creation time &
metallicity for star particles - the level can be worked out from dx).
Each processor only writes information that is local to it, so any image
generator must read all of the processor files.
Greg Bryan has written a simple movie generator that reads this format and creates
a series of images (contact him for this code),
as well as giving an example
of how to read the data file format. The grid/dm/star particle files
are written in raw binary output (using C's fwrite command), so they may
not be readable on other machines besides the one that enzo was run on
(we should probably use John Shalf's IEEEIO...) Finally, this format
is subject to change without notice (in fact, everything in this guide
is subject to change without notice).
Go to the Enzo home page
© 2004 Laboratory for Computational Astrophysics
last modified February 2004
by B.W. O'Shea


Server port: WiFi key: This is necessary to include new devices into the network
Network Interface: If you have multiple network interfaces, you can select the correct one
on save adapter restarts with new config immediately
add device please wait...


\framebox[width][position]{text}
The \framebox command is exactly the same as the \makebox command, except that it puts a frame around the outside of the box that it creates.
The framebox command produces a rule of thickness \fboxrule, and leaves a space \fboxsep between the rule and the contents of the box.
The \framebox command is fragile.
\framebox(width,height)[position]{...}
The \framebox command is exactly the same as the \makebox command, except that it puts a frame around the outside of the box that it creates.
See also \fbox,
\makebox,
\dashbox
See also Spaces and Boxes,
Picture Environment.
Return to LaTeX Table of Contents.


{% extends 'topbase.html' %} {% block main_content %} {% if validlink %}
Reset Password
The Password Link has Expired or is Invalid!
Please request a new password reset.Here!


This is a simple pre space it should work well just making sure
A second block good to test with
this is the last block and it should continue to work no matter what


{% include 'includes/head.html' %}
{% include 'includes/nav.html' %}If a crime were to occur to you, there would be a {{ card.probability }}% probability, our prediction analysis shows that there is a of for {{ card.prediction }} at {{ card.address }}.
Regardless of the prediction above, always exercise caution, especially late at night.


--- layout: page title: "Blog" permalink: /blog/ description: "Articles, News and Updates" ---
{{ post.description }}
Read More


?6
7
8
9
10
L
.
.
.
The
New
York
Copyright
reserved
Botanical
Garden
HERBARIUM
OF
THE
UNIVERSITY
OF
SOUTH
FLORIDA,
TAMPA
t'iC.
BOTANICAL
<$£>IMAG£D
010717
PLANTS
OF
PUERTO
RICO
W)
Jasminum
multiflorum
(Burm.f.)Andr.
Mun.
de
Barranquitas:
Along
Hwy
156,
6.4
mi.
SW
of
Comerio;
5.1
mi.
SW
of
junction
with
Hwy
776.
Disturbed
roadside.
Shrub
1
m
tall;
flowers
white.
Bruce
Hansen,
R.
P.
Sauleda,
M.
Ragan
&
J.
Lopez
25
November
1981
No.
9332
01071716
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


Simple pricing
Try Sigma for free for 30 days with full features, no credit card required, no commitment required. Then upgrade your account after that when you're ready.
Start your trialTry one of our flexible plans
- No credit card required
- Cancel anytime
- 30 day free trial
Users
Templates
Emails
Bandwidth
Support
Integrations
Backups
Essential
Keep things simple and try our services with our basic plan.
$19/mo
Billed annually, per team member
1 team member
20 templates
30 emails per week
100GB bandwidth
Email support
15 integrations
Weekly backups
Agency
Perfect for small to mid-sized companies and agencies.
$45/mo
Billed annually, per team member
10 team members
500 templates
1000 templates per week
Unlimited bandwith
Email, Telephone support
15 integrations
Hourly backups
Need Enterprise?
Our Enterprise package is custom-built per client - ideal for large businesses.
Discuss your requirements- Custom package per client
- Unlimited resources
- Add additional features
Already trusted by thousands of brands
Frequently asked questions
Nunc et sollicitudin libero. Etiam eget sollicitudin eros. In non mauris feugiat,
gravida dolor ac, gravida diam. Suspendisse elementum hendrerit massa, in molestie
tortor pretium vel. Donec sed finibus libero. Cras at diam quis lacus interdum
pellentesque. Aenean at luctus est. Phasellus facilisis neque luctus nibh venenatis, eu
viverra odio interdum. Morbi aliquam mi in ultrices gravida. Nunc quis sodales mauris.
Donec cursus consequat nulla, a imperdiet eros pulvinar nec. Aenean iaculis massa vel
aliquet iaculis. Vivamus orci metus, dignissim sed elit ac, euismod consectetur dui.
Mauris at enim magna. Suspendisse ut urna vitae odio malesuada tempor vitae egestas ex.
Sed a tortor suscipit urna efficitur fringilla. Integer aliquam erat ut eros egestas, eu
laoreet elit pellentesque. Nunc at urna vel ligula blandit placerat.
Maecenas vitae metus urna. Morbi mattis, nulla at tempus viverra, urna eros tincidunt
risus, porttitor sollicitudin leo ligula ut felis. Integer pharetra, dui nec tincidunt
posuere, quam est efficitur nisl, non porta justo diam molestie sem.


Inline vs Inline-block
What does it mean to display "inline" vs using "inline block?"
When altering the display property of an element in CSS, there are several options. Two of the most common ones are "inline" and "inline-block." By designating an element's display property as "inline," no line break will be created before or after the element. It will appear on the same line as the inline elements around it.
"Inline-block" is used when you want an element to have no line breaks before or after it, but retain it's own dimensions.
This h2 is displayed inline
with this p section
This is a sample sentence with a picture
that has a display property of "inline-block." It has a designated height and width.


Extended guide on how to use the model
| product_name | description |
|---|---|
| Nike Air Force | A modern version of the iconic AF1, combining classic style and modern details [..] |
| product_name | description | tags |
|---|---|---|
| Nike Air Force | A modern version of the iconic AF1, combining classic style and modern details [..] | [modern, AF1, iconic, classic] |


Task List
Create New Task
Currently Editing Task: {{task_id}}
{{title}}
Task Name
Task Name Required
Task Description
Importance
level 1
level 2
level 3
level 4
level 5
level 6
level 7
level 8
level 9
Minutes before alarm
minutes
Due Date
Due Time
Completed
Cancel
{{buttonText}}
Delete


This tool allows you to listen to a song from your library with your full attention. Select songs from your playlist so that you may use this tool. If you prefer, you can skip this step and simply listen to sounds in your surrounding environment.


References
Ahlmann-Eltze, Constantin, and Indrajeet Patil. 2021. Ggsignif: Significance Brackets for Ggplot2. https://CRAN.R-project.org/package=ggsignif.
Allen, Micah, Davide Poggiali, Kirstie Whitaker, Tom Rhys Marshall, Jordy van Langen, and Rogier A. Kievit. 2021. “Raincloud Plots: A Multi-Platform Tool for Robust Data Visualization.” Wellcome Open Research 4 (January): 63. https://doi.org/10/ghvbc6.
Constantin, Ahlmann-Eltze, and Indrajeet Patil. 2021. “ggsignif: R Package for Displaying Significance Brackets for ’ggplot2’.” PsyArxiv. https://doi.org/10.31234/osf.io/7awm6.
Garnier, Simon. 2021a. Viridis: Colorblind-Friendly Color Maps for R. https://CRAN.R-project.org/package=viridis.
———. 2021b. ViridisLite: Colorblind-Friendly Color Maps (Lite Version). https://CRAN.R-project.org/package=viridisLite.
Harrell, Frank E, Jr. 2021. Hmisc: Harrell Miscellaneous. https://CRAN.R-project.org/package=Hmisc.
Henry, Lionel, and Hadley Wickham. 2020. Purrr: Functional Programming Tools. https://CRAN.R-project.org/package=purrr.
Hernandez, Jose Guadalupe, Alexander Lalejini, and Charles Ofria. 2021. “An Exploration of Exploration: Measuring the Ability of Lexicase Selection to Find Obscure Pathways to Optimality.” arXiv:2107.09760 [Cs], July. http://arxiv.org/abs/2107.09760.
Kassambara, Alboukadel. 2020. Ggpubr: Ggplot2 Based Publication Ready Plots. https://rpkgs.datanovia.com/ggpubr/.
———. 2021. Rstatix: Pipe-Friendly Framework for Basic Statistical Tests. https://rpkgs.datanovia.com/rstatix/.
Meyer, Patrick E. 2014. Infotheo: Information-Theoretic Measures. http://homepage.meyerp.com/software.
Müller, Kirill, and Hadley Wickham. 2021. Tibble: Simple Data Frames. https://CRAN.R-project.org/package=tibble.
Neuwirth, Erich. 2014. RColorBrewer: ColorBrewer Palettes. https://CRAN.R-project.org/package=RColorBrewer.
R Core Team. 2021. R: A Language and Environment for Statistical Computing. Vienna, Austria: R Foundation for Statistical Computing. https://www.R-project.org/.
Sarkar, Deepayan. 2008. Lattice: Multivariate Data Visualization with R. New York: Springer. http://lmdvr.r-forge.r-project.org.
———. 2021. Lattice: Trellis Graphics for R. http://lattice.r-forge.r-project.org/.
Terry M. Therneau, and Patricia M. Grambsch. 2000. Modeling Survival Data: Extending the Cox Model. New York: Springer.
Therneau, Terry M. 2021. Survival: Survival Analysis. https://github.com/therneau/survival.
Wickham, Hadley. 2016. Ggplot2: Elegant Graphics for Data Analysis. Springer-Verlag New York. https://ggplot2.tidyverse.org.
———. 2019. Stringr: Simple, Consistent Wrappers for Common String Operations. https://CRAN.R-project.org/package=stringr.
———. 2021a. Forcats: Tools for Working with Categorical Variables (Factors). https://CRAN.R-project.org/package=forcats.
———. 2021b. Tidyr: Tidy Messy Data. https://CRAN.R-project.org/package=tidyr.
———. 2021c. Tidyverse: Easily Install and Load the Tidyverse. https://CRAN.R-project.org/package=tidyverse.
Wickham, Hadley, Mara Averick, Jennifer Bryan, Winston Chang, Lucy D’Agostino McGowan, Romain François, Garrett Grolemund, et al. 2019. “Welcome to the tidyverse.” Journal of Open Source Software 4 (43): 1686. https://doi.org/10.21105/joss.01686.
Wickham, Hadley, Winston Chang, Lionel Henry, Thomas Lin Pedersen, Kohske Takahashi, Claus Wilke, Kara Woo, Hiroaki Yutani, and Dewey Dunnington. 2021. Ggplot2: Create Elegant Data Visualisations Using the Grammar of Graphics. https://CRAN.R-project.org/package=ggplot2.
Wickham, Hadley, Romain François, Lionel Henry, and Kirill Müller. 2021. Dplyr: A Grammar of Data Manipulation. https://CRAN.R-project.org/package=dplyr.
Wickham, Hadley, and Jim Hester. 2020. Readr: Read Rectangular Text Data. https://CRAN.R-project.org/package=readr.
Wickham, Hadley, and Dana Seidel. 2020. Scales: Scale Functions for Visualization. https://CRAN.R-project.org/package=scales.
Wilke, Claus O. 2020. Cowplot: Streamlined Plot Theme and Plot Annotations for Ggplot2. https://wilkelab.org/cowplot/.
Wolen, Aaron, and Chris Hartgerink. 2020. Osfr: Interface to the Open Science Framework (Osf). https://CRAN.R-project.org/package=osfr.
Wolen, Aaron R., Chris H.J. Hartgerink, Ryan Hafen, Brian G. Richards, Courtney K. Soderberg, and Timothy P. York. 2020. “osfr: An R Interface to the Open Science Framework.” Journal of Open Source Software 5 (46): 2071. https://doi.org/10.21105/joss.02071.
Xie, Yihui. 2014. “Knitr: A Comprehensive Tool for Reproducible Research in R.” In Implementing Reproducible Computational Research, edited by Victoria Stodden, Friedrich Leisch, and Roger D. Peng. Chapman; Hall/CRC. http://www.crcpress.com/product/isbn/9781466561595.
———. 2015. Dynamic Documents with R and Knitr. 2nd ed. Boca Raton, Florida: Chapman; Hall/CRC. https://yihui.org/knitr/.
———. 2016. Bookdown: Authoring Books and Technical Documents with R Markdown. Boca Raton, Florida: Chapman; Hall/CRC. https://bookdown.org/yihui/bookdown.
———. 2021a. Bookdown: Authoring Books and Technical Documents with R Markdown. https://CRAN.R-project.org/package=bookdown.
———. 2021b. Knitr: A General-Purpose Package for Dynamic Report Generation in R. https://yihui.org/knitr/.
Xie, Yihui, J. J. Allaire, and Garrett Grolemund. 2019. R Markdown: The Definitive Guide. Boca Raton: CRC Press, Taylor; Francis Group.
Zeileis, Achim, and Yves Croissant. 2010. “Extended Model Formulas in R: Multiple Parts and Multiple Responses.” Journal of Statistical Software 34 (1): 1–13. https://doi.org/10.18637/jss.v034.i01.
———. 2020. Formula: Extended Model Formulas. https://CRAN.R-project.org/package=Formula.
Zhu, Hao. 2021. KableExtra: Construct Complex Table with Kable and Pipe Syntax. https://CRAN.R-project.org/package=kableExtra.


THE-HOT-TEA-SHOP
HotTea-Delivering your beverage Promptly
Since 1975
Name
Address
Phone Number
Password
Enter a password longer than 8 characters
Confirm Password
HotTea-Delivering your beverage Promptly
Since 1975


This recipe is based on one from Bob's Red Mill
Ingredients
| Ingredient | For 1, 9-10" pie |
| Bob's Paleo Baking Flour | 1.25 cups (115 g) |
| eggs | 2 |
| water | 2 TBSP |
| olive oil | 2 TBSP |
| baking powder | 0.5 tsp |
| salt | 1/4 tsp |
| pizza sauce | ~1/2 cup |
| shredded cheese | ~10 oz |
| other pizza ingredients | use your imagination |
Procedure
- Sift flour, salt, and baking powder into mixing bowl.
- Mix the eggs, water, and oil and add to flour mix.
- Allow dough to sit for a few (~5) minutes.
- Preheat oven to 375o. Don't forget pizza stone if you use one.
- Roll out dough between two sheets of parchment paper
- Prebake pizza crust for 7 minutes.
- Add ingredients as desired (simple suggestion sauce then cheese).
- Bake the pie for about 5-7 minutes at 400o.
- Remove pie, slice and eat!
Ingredients
| Ingredient | For 1, 10" pie |
| Bob's Paleo Baking Flour | 1.5 cups (138 g) |
| baking powder | 1 tsp |
| eggs | 2 |
| buttermilk | 2/3 cup (160 g) |
| butter | 1.5 Tbsp |
| toppings | to taste |
Procedure
- Preheat oven to 430o
- Place 10" cast iron skillet in oven to preheat
- Mix eggs and buttermilk
- Mix flour and baking powder
- Stir flour mixture into liquid. Mix will be sticky but
should be just runny enough to distribute in pan by tilting.
- Melt butter in skillet
- Pour mixture into skillet, tilting in a circular motion to
distribute around pan. If possible, try to get the center a bit
thinner than the edges.
- Bake at 430o for about 12 minutes or until
center feels firm enough to hold up to toppings.
- Optional: This dough does not naturally make a depression
for the pizza toppings. After 3-4 minutes (of the 12 minutes
above), butter the bottom of an appropriately-sized
flat-bottomed dish (e.g., a round casserole) or pie dish and
press into dough for 30 - 60 seconds until the depression is a
desired depth and stays in place.
- Place toppings on pie and bake at 400o until
ready. Total baking time should be around 20-22 minutes to give
crust enough time to bake.
Ingredients
| Ingredient | For 3, 9-10" pies |
| buckwheat flour | 155 g |
| almond meal | 205 g |
| eggs | 2 |
| water | 2/3 cup |
| bread yeast | 1.5 tsp |
| sugar | 1 tsp |
| salt | ?? tsp |
| pizza sauce | ~1/2 cup |
| shredded cheese | ~10 oz |
| other pizza ingredients | use your imagination |
Procedure
- Add sugar to water and heat until it is about 105o
F.
- Add yeast to water and stir. Allow to sit until yeast is fully awake
(nice head of foam on top).
- Measure flours into mixing bowl.
- Add yeast mixture and eggs (beaten) to flour.
- Knead by hand as if making bread. Add water as neccessary (should
use most of the water). Dough may be too sticky to use hands,
using a spoon or spatula is okay.
- When the dough is almost ready, knead in the salt (if any).
- Allow dough to sit covered in a warm environment for about 1.5 hours.
- Preheat oven to 375o. Don't forget pizza stone if you use one.
- Divide dough in three (about 200g per pie) and roll out each
piece until it fits a 9" pizza pan. Use parchment paper to avoid
sticking
- Prebake pizza crust for 10-15 minutes. Remove and cool slightly.
- Add ingredients as desired (simple suggestion sauce then cheese).
- Bake pies for about 12 minutes. Bake directly on stone for crispiest
crust. Use a pan with holes for a medium crust and a full-bottom pan for
softer crust.
- Remove pie, slice and eat!
Ingredients
| Ingredient | For 2, 9" pies |
| whole wheat flour | 14 oz |
| water | 1 1/4+ cups |
| bread yeast | 1.5 tsp |
| sugar | 1 tsp |
| salt | 1 tsp |
| pizza sauce | ~1/2 cup |
| shredded cheese | ~10 oz |
| other pizza ingredients | use your imagination |
Procedure
- Add sugar to 1/2 cup of water and heat until it is about 105o
F.
- Add yeast to water and stir. Allow to sit until yeast is fully awake
(nice head of foam on top).
- Measure flour into mixing bowl.
- Add yeast mixture and 3/4 cup of water to flour.
- Knead in mixer or by hand as if making bread. Add water as neccessary.
- When the dough is almost ready, knead in the salt.
- Allow dough to sit covered in a warm environment for about 1.5 hours.
- Preheat oven to 450o. Don't forget pizza stone if you use one.
- Punch the dough and divide in two. Knead a little to increase firmness
(but not so much that it won't roll out).
- Roll out each piece until it fits a 9" pizza pan.
- Add ingredients as desired (simple suggestion sauce then cheese).
- Bake pies for about 12 minutes. Bake directly on stone for crispiest
crust. Use a pan with holes for a medium crust and a full-bottom pan for
softer crust.
- Remove pie, slice and eat!
Copyright ©, 2003-2021, Steve Goldhaber


The release model is associate with the Release Server model, which allows you to deploy your code via FTP or SFTP to your web server.
repository_id is required. Either name of the repo or it’s ID can be used. Use page parameter to skim through pages. Beanstalk will send 20 releases per page.
GET /api/repo_name/releases.xml
Click to expand…
http-response<?xml version="1.0" encoding="UTF-8"?>
<releases type="array">
<release>
<account-id type="integer">23452</account-id>
<author>gilbert</author>
<comment>Deploying yesterday's changes.</comment>
<created-at type="datetime">
2009-11-04T10:03:29Z
</created-at>
<deployed-at type="datetime">
2009-11-04T10:03:40Z
</deployed-at>
<id type="integer">2547</id>
<last-retry-at type="datetime" nil="true"></last-retry-at>
<repository-id type="integer">98765</repository-id>
<environment-name>Staging</environment-name>
<environment-id>6</environment-id>
<retries type="integer">0</retries>
<revision type="integer">81</revision>
<state>complete</state>
<updated-at type="datetime">
2009-11-04T10:03:40Z
</updated-at>
</release>
<release>
<account-id type="integer">8765</account-id>
<author>ilya</author>
<comment>Going crazy</comment>
<created-at type="datetime">
2008-06-26T17:02:22Z
</created-at>
<deployed-at type="datetime">
2008-06-26T17:03:30Z
</deployed-at>
<id type="integer">6543</id>
<last-retry-at type="datetime" nil="true"></last-retry-at>
<repository-id type="integer">8967</repository-id>
<environment-name>Staging</environment-name>
<environment-id>6</environment-id>
<retries type="integer">0</retries>
<revision type="integer">249</revision>
<state>complete</state>
<updated-at type="datetime">
2008-11-04T14:50:01Z
</updated-at>
</release>
</releases>
Beanstalk::API::Release.find_all_for_environment(environment_id=7, "repo", page=nil)
repository_id is required. Either name of the repo or it’s ID can be used. Release ID is required.
GET /api/repo_name/8765.xml
Click to expand…
http-response<?xml version="1.0" encoding="UTF-8"?>
<release>
<account-id type="integer">8765</account-id>
<author>ilya</author>
<comment>Going crazy</comment>
<created-at type="datetime">
2008-06-26T17:02:22Z
</created-at>
<deployed-at type="datetime">
2008-06-26T17:03:30Z
</deployed-at>
<id type="integer">6543</id>
<last-retry-at type="datetime" nil="true"></last-retry-at>
<repository-id type="integer">8967</repository-id>
<environment-name>Staging</environment-name>
<environment-id>6</environment-id>
<retries type="integer">0</retries>
<revision type="integer">249</revision>
<state>complete</state>
<updated-at type="datetime">
2008-11-04T14:50:01Z
</updated-at>
</release>
Beanstalk::API::Release.find_for_repository(8765, "repo")
Creating a release means requesting a deployment. If you already have some releases in state “new” or “retry”, Beanstalk will delete them after creating a new one.
See the list of writable attributes at the top of the page. Both revision and release_server_id are required. release_server_id should be an ID of an enabled server under your account.
POST /api/repo_name/releases.xml/?environment_id=6
<release>
<revision type="integer">1</revision>
</release>
Click to expand…
http-response<?xml version="1.0" encoding="UTF-8"?>
<release>
<account-id type="integer">23452</account-id>
<author>gilbert</author>
<comment>Deploying yesterday's changes.</comment>
<created-at type="datetime">
2009-11-04T10:03:29Z
</created-at>
<deployed-at type="datetime">
2009-11-04T10:03:40Z
</deployed-at>
<id type="integer">2547</id>
<last-retry-at type="datetime" nil="true"></last-retry-at>
<repository-id type="integer">98765</repository-id>
<environment-name>Staging</environment-name>
<environment-id>6</environment-id>
<retries type="integer">0</retries>
<revision type="integer">81</revision>
<state>complete</state>
<updated-at type="datetime">
2009-11-04T10:03:40Z
</updated-at>
</release>
--OR IF INVALID--
<?xml version="1.0" encoding="UTF-8"?>
<errors>
<error>Server can't be blank</error>
</errors>
r = Beanstalk::API::Release.new
r.prefix_options = { :repository_id => 58, :environment_id => 6 }
r.revision = 1
r.save


{% block head %}{% endblock %}
Toggle navigation
DISCOVER
EXPERIENCE
COMMUNITY
PORTAL
Logout
×
Upload a Dataset
Choose a file
*
{% block content %}{% endblock %}
Canadian Open Neuroscience Platform
(2019)
Code available on
Github


Aggregation Constructors
-
A single-value metrics aggregation that keeps track and returns the minimum value among numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script.
See moreDeclaration
Swift
public struct MinAggregation : Aggregation
-
A single-value metrics aggregation that sums up numeric values that are extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script.
See moreDeclaration
Swift
public struct SumAggregation : Aggregation
-
A multi-value metrics aggregation that computes stats over numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script.
The stats that are returned consist of: min, max, sum, count and avg.
See moreDeclaration
Swift
public struct StatsAggregation : Aggregation
-
A single-value metrics aggregation that keeps track and returns the maximum value among the numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script.
See moreDeclaration
Swift
public struct MaxAggregation : Aggregation
-
A single-value metrics aggregation that computes the average of numeric values that are extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script.
See moreDeclaration
Swift
public struct AvgAggregation : Aggregation
-
A metric aggregation that computes the weighted centroid from all coordinate values for a Geo-point datatype field.
See moreDeclaration
Swift
public struct GeoCentroidAggregation : Aggregation
-
A metric aggregation that computes the bounding box containing all geo_point values for a field.
See moreDeclaration
Swift
public struct GeoBoundsAggregation : Aggregation
-
A top_hits metric aggregator keeps track of the most relevant document being aggregated. This aggregator is intended to be used as a sub aggregator, so that the top matching documents can be aggregated per bucket.
The top_hits aggregator can effectively be used to group result sets by certain fields via a bucket aggregator. One or more bucket aggregators determines by which properties a result set get sliced into.
See moreDeclaration
Swift
public struct TopHitsAggregation : Aggregation
-
A single-value metrics aggregation that calculates an approximate count of distinct values. Values can be extracted either from specific fields in the document or generated by a script.
See moreDeclaration
Swift
public struct CardinalityAggregation : Aggregation
-
A single-value metrics aggregation that counts the number of values that are extracted from the aggregated documents. These values can be extracted either from specific fields in the documents, or be generated by a provided script. Typically, this aggregator will be used in conjunction with other single-value aggregations. For example, when computing the avg one might be interested in the number of values the average is computed over.
See moreDeclaration
Swift
public struct ValueCountAggregation : Aggregation
-
A multi-value metrics aggregation that computes stats over numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script.
The extended_stats aggregations is an extended version of the stats aggregation, where additional metrics are added such as sum_of_squares, variance, std_deviation and std_deviation_bounds.
See moreDeclaration
Swift
public struct ExtendedStatsAggregation : Aggregation
-
A multi-bucket value source based aggregation where buckets are dynamically built - one per unique value.
See moreDeclaration
Swift
public struct TermsAggregation : Aggregation


Table of Contents
[ref. OpenBSD FAQ : 10.0 System Management -> 10.12 Setting up Anonymous FTP Services]
Security Warning: Default ftpd behaviour is to allow all users access to the root-directory, this can be a significant compromise. Use -A, anonymous access which is chroot to /home/ftp. Valid User accounts can be forced ftp access only to their home directories (eg. /home/janedoe)
Again: chroot is not the default behaviour of ftpd.
Secure Alternative A (also known as "I've just discovered sftpserver")
Get your clients to use an ftp client that supports Secure FTP or sftp. OpenBSD delivers OpenSSH (since 2.6) which also has a component for secure ftp (sftp - unix client, sftpserver - unix server [since 2.9?].) If you require secure FTP then you will have the 'features' of FTP together with the security of OpenSSH.
A Windows ftp client that supports sftp is GlobalScape's CuteFTP Pro 1.0
Now if only I can I can get my web site to upgrade to OpenSSH 2.x
Secure Alternative B (also known as, document what you've been using)
Although less interactive, and in my experience much slower than ftp, you can use a combination of OpenSSH's ssh client and scp (Secure Copy.) This is a reasonable alternative using character based Unix shells.
A number of MS Windows clients which I have used including WinSCP, Putty, and iXplorer. You could also go for commercialware from the originators, SSH Secure Shell at www.ssh.com. For a more complete list of alternative clients please visit the OpenSSH website.
Before we can setup the ftp user account, we 1st need to configure the 'shell' we will allocate for anonymous users: /usr/bin/false.
The /usr/bin/false is a short sh script that exits if any user attempts to connect to the system through the account. It is installed during the default installation but not included in /etc/shells, which provides the options for shells for user accounts.
File: /usr/bin/false
| #! /bin/sh # CONTENTS OF /usr/local/false # $OpenBSD: false.sh,v 1.2 1996/06/26 05:32:50 deraadt Exp $ exit 1 |
Edit the file: /etc/shells and include a line to /usr/bin/false. Verify that false is in the /usr/bin directory. The /etc/shells file should end up looking similar to the below.
Edit: /etc/shells
| # $OpenBSD: shells,v 1.5 1997/05/28 21:42:20
deraadt Exp $ # List of acceptable shells for chpass(1). # Ftpd will not allow users to connect who are not using # one of these shells. /bin/sh /bin/csh /bin/ksh /usr/local/bin/bash |
| /usr/bin/false |
Create the ftp account using "adduser" with the below option, and a blank password.
| User Name: ftp Full Name: Anonymous FTP Shell: false Login Group: ftp Invite to other Groups: No Enter Password []: <<leave-blank>> Set the password so that user cannot logon? (y/n) [n]: y |
Change/ensure the ownership of the ftp root directory is owned by root, and files are read-only.
| # chown root.root /home/ftp # chmod 555 /home/ftp # mkdir /home/ftp/pub # chmod 555 /home/ftp/pub |
We change the mode to readonly execute, so people can traverse directories and read the files but cannot delete or move files.
From the man pages (and FAQ,) the below are suggested directories, but are not required for the server to operate.
| ~/ftp/bin | Make this directory owned by "root" and unwritable by anyone (mode 511). This directory is optional unless you have commands you wish the anonymous ftp user to be able to run (the ls(1) command exists as a builtin). Any programs in this directory should be mode 111 (executable only) |
| ~/ftp/etc | Make this directory owned by "root" and unwritable by anyone (mode 511). The files pwd.db (see pwd_mkdb(8)) and group(5) must be present for the ls command to be able to produce owner names rather than numbers. The password field in pwd.db is not used, and should not contain real passwords. The file motd, if present, will be printed after a successful login. These files should be mode 444 |
| ~/ftp/pub | Make this directory mode 555 and owned by "root". This is traditionally where publically accessible files are stored for download |
| /etc/ftpusers | List of unwelcome/restricted users |
| /etc/ftpchroot | List of normal users who should be chroot'd |
To maximise security we take a look at denying access to some users, and restricting access to everyone else.
Deny Access: Add users we want to have no access to the ftp services into the /etc/ftpusers file. The standard installation prevents access by special service accounts (eg. root, bin, daemon, operator, uucp, www, named.) To be safe, consider adding other accounts used by daemon services, such as: mysql, samba to /etc/ftpusers.
With the -A switch we effectively deny access to accounts not listed in the /etc/ftpchroot file.
Restrict Access: (chroot) If you provide ftp access for your user-accounts, add all users (not restricted above) to /etc/ftpchroot. ftpd will allow access by ftp accounts to the root directory, we can enforce some security by allowing chroot to force each login into their private directory.
[ref: login.conf(5), ftpd(8)]
[ref: e-mail from Joakim Aronius]
[ref: OpenBSD 3.0]
OpenBSD's login classes give us another method for structuring security privileges for our ftp clients. /etc/login.conf is the configuration file that determines your grouping/privilege settings.
In login.conf one can add default values for any user class:
The simplest example, is to merely change the 'default' setting. In the example below, our login.conf settings will ensure all accounts are chrooted without the need to enter all users into the /etc/ftpchroot file.
e.g. Extract from the file /etc/login.conf
| default:\ :path=/usr/bin /bin /usr/sbin /sbin /usr/X11R6/bin /usr/local/bin:\ :umask=022:\ :datasize-max=256M:\ :datasize-cur=64M:\ :maxproc-max=128:\ :maxproc-cur=64:\ :openfiles-cur=64:\ :stacksize-cur=4M:\ :localcipher=blowfish,6:\ :ypcipher=old:\ :tc=auth-defaults:\ :tc=auth-ftp-defaults:\ |
| :ftp-chroot:\ :ftp-dir=~: |
With the above settings we are ready to roll with our more secured, chrooted
ftp server.
From the man pages of ftpd(8)
|
LOGIN.CONF Variables |
|
| ftp-chroot | A boolean value. If set, users in this class will be automatically chrooted to the user's login directory. |
| ftp-dir | A path to a directory. This value overrides the login directory for users in this class. A leading tilde (`~') in ftp-dir will be expanded to the user's home directory based on the contents of the password database. |
A users class is set in the fifth field of the user record in the passwd(5) file. This field is not set on new users when you add them with adduser etc, hence we all become default. (the other pre defined classes are daemon and staff)
If you do not wish for all users to be treated the same, then you could add a new class (e.g.'ftpusers'.) This way you can set a whole bunch of parameters specific to only these users.
Gratitudes to Joakim Aronius for pointing (and documenting) this out for
us.
To auto-start ftpd with each system start-up we change the settings in the /etc/rc.conf.local We can also manually start the service with the same flags at the command prompt.
Edit /etc/rc.conf.local:
| ftpd_flags="-DllUSA" # for non-inetd use: ftpd_flags="-D" |
You can also enable ftpd through inetd (described in the FAQ) but making the above settings in the /etc/rc.conf.local is what I like. Obviously, we can now start the ftpd server manually from the command-line.
| # /usr/libexec/ftpd -DllUSA |
The command will run ftpd in the background and you are now ready to check your ftp server whether it has been configured correctly.
From the man pages:
The switches listed above are described further [man pages.]
| D | Detach and become a daemon, accepting connections on the FTP port and forking child processes to handle them. This has lower overhead than starting ftpd from inetd(8) and is thus useful on busy servers to reduce load. |
| l |
lower-case L, log successful and failed ftp(1) session using syslog. When specified twice (eg. -ll,) the log will also include: retrieve (get), store (put), append, delete, make directory, remove directory and rename operations and their filename arguments. |
| U | Log each concurrent ftp(1) session to the file /var/run/utmp, making them visible to commands such as who(1). |
| S | Log all anonymous downloads to the file /var/log/ftpd when this file exists. |
| A | Permit only anonymous ftp connections or accounts listed in /etc/ftpchroot. Other connection attempts are refused. |
Other configuration files of interest are:
| /etc/nologin | The file can be used to disable ftp access. If the file exists, ftpd displays it and exits. |
| /etc/ftpwelcome | Welcome notice. This holds the Welcome message for people once they have connected to your ftp server. |
| /etc/motd | Welcome notice after login. This holds the message for people once they have successfully logged into your ftp server |
| .message | This file can be placed in any directory. It will be shown once a user enters that directory. |
| /var/run/utmp | List of users on the system |
| /var/run/ftpd.pid | Process id if running in daemon mode |
| /var/log/ftpd | Log file for anonymous downloads |
FTP Server Behind a NAT Gateway Using OpenBSD 3.0 http://www.svartalfheim.net/natftp.html
Copyright (c) 2000/1/2 Samiuela LV Taufa. All Rights Reserved.
I reserve the right to be totally incorrect even at the best advice of betters.
You are permitted and encouraged to use this guide for fun or for profit as you see fit. If you republish this work in what-ever form, it would be nice (though not enforceable) to be credited.
|
FTP Anonymous Server - Serving Up Files |
Copyright © 2000/1/2 NoMoa.COM All rights reserved.


Xehanort's Team
Xehanort
Manager
ID: 1
Email:
<EMAIL_ADDRESS>Office number: 13
Xemnas
Engineer
ID: 2
Email:
<EMAIL_ADDRESS>GitHub:
cabralwilliams
Ansem
Engineer
ID: 3
Email:
<EMAIL_ADDRESS>GitHub:
cabralwilliams
Saix
Intern
ID: 8
Email:
<EMAIL_ADDRESS>School: Rice University


Antimatter Dimensions is an Idle Incremental game with multiple layers of unlocks, prestige, and achievements. The basic Goal is to reach infinity and receive an infinity point, which can be spent on various skills to increase your overall production.
You can choose whether or not you would like to see spoilers here. Setting this to "Avoid spoilers" will only show the content you have access to, as well as the next piece(s) of content you will unlock.
Dimensions:
Dimensions are your production units in game. The first Dimension produces your Antimatter. Each consecutive dimension produces the previous one, allowing you to have steady growth. There are eight dimensions total.
Dimension Multiplier: Beside the dimension there is a multiplier (example: First Dimension x1.0). The base production of each dimension is multiplied by this number. This multiplier increases by 2x(Base) for every 10 of that dimension purchased. Each time this occurs, the price of the dimension will increase.
Accumulated Dimension Quantity: The next column is your current amount of that dimension you own. This is a combination of how many you have purchased with antimatter, as well as produced from the higher dimension.
Purchased Dimensions Quantity: Next to each accumulated quantity of owned dimensions, the amount of that dimension purchased toward the next multiplier upgrade is displayed in brackets. If you have (4) next to your accumulated dimension quantity, you will need 6 more of that dimension for the next multiplier increase.
Dimension Growth Percent: This number represents the amount of growth that dimension experiences per second. +100% means the dimension is doubling each second. This allows you to judge overall growth.
Cost & until 10: You can buy a single quantity of each dimension with antimatter when the cost button is highlighted. Alternatively, if the Until 10 button is highlighted, you can buy whatever quantity gets you to that dimensions next dimension multiplier.
Max all: Max all will buy max tickspeed (see below), then will buy until 10 of 8th dimension until it can't anymore, then 7th, and so on.
Dimension base prices: 10, 100, 10000, 1e6, 1e9, 1e13, 1e18, 1e24
Base per 10 bought dimension price increases:1000, 10000, 1e5, 1e6, 1e8, 1e10, 1e12, 1e15
Hotkeys: 1, 2, 3, 4, 5, 6, 7, 8 for buy until 10 []th dimension, M for Max all
Tick: Production in the game happens on each “tick”.
Interval: The length of time between ticks. This is lowered by purchasing tick interval reductions.
Cost: The cost in antimatter for reducing the tick interval by the % displayed above (Without Galaxies your base tickspeed decrease is 11% per purchase)
Buy Max: This will buy the maximum amount of tick interval decreases available with your current amount of Antimatter.
Note that the actual tickspeed time is fake and the game always runs at 20 ticks per second.
Dimension Shift: This resets your current game, but unlocks another dimension for your next run. Each one requires 20 (base) of your highest unlocked dimension.
Dimension Boost: A dimension shift, but you don't unlock a new dimension. This happens after 4 dimension shifts. Each one requires 20+(boosts*15) (base) eighth dimensions.
Each dimension shift and boost will provide a x2 (base) multiplier to first dimension, and each dimension after will have half (base) multiplier as the previous (min 1).
Hotkey: D
Purchasing an Antimatter Galaxy will reset your game back to the point where only 4 Dimensions are available, but will increase the effect of your tick speed interval reduction by 2%.
Though it will have very little impact for the first few purchases, the increase is multiplicative and won’t take long to be visible.
Your first galaxy will increase your tickspeed interval upgrade as if it were 10% originally, so you will have 12% after 1 galaxy.
Galaxies require 80+(galaxies*60) (base) Eighth Dimensions. (80+galaxies*60+(galaxies-99)^2*2 when above 100 non-replicanti galaxies, with even faster scaling later on)
Hotkey: G
You unlock Dimensional Sacrifice after your first dimensional boost.
Sacrificing will immediately reduce the owned quantity of dimensions 1 through 7 to zero. This does not reduce the multiplier or the current cost. In return, it will multiply the Eighth Dimension Multiplier by the shown value. It will take time to get back to the production you previously had, but you will end up with a net increase.
When should I Sacrifice? Depends on your percentages (+%/s), but if they are over ~2% and the multiplier is over 2x, I'd say it's worth it. The lower the percentage, the longer it takes to gain back your dimensions.
Dimensional Sacrifice Checkbox: This allows you to complete dimensional sacrifices without having the warning popup.
The dimensional sacrifice formula (where n is the total amount of first dimensions you've had) is:
Base: (log(n)/10)^m, where m is 2 at base, 2.2 with the "The Gods are pleased" achievement, and 2.5 with the "Gift from the Gods" achievement.
Eighth Dimension Autobuyer Challenge: m^0.05/n^0.04*j, where m is the current number of first dimensions you have and j is your previous sacrifice multiplier.
After Infinity Challenge 2: n^m, where m is 0.01 at base and 0.011 with the "Yet another infinity reference" achievement.
Hotkey: S
Once you have too much Antimatter for the world to handle (2^1024, or 1.7976931348623159e308) you’ll reach infinity and be able to perform a “Big Crunch”.
Each Infinity completed will give an Infinity Point. These can be spent on upgrades in the new infinity tab. You must purchase these upgrades from top to bottom.
The "x2 IP from all sources" upgrade can be bought multiple times, but each purchase requires 10 times as much IP. You must buy all 16 previous infinity upgrades to buy the first level_.
When should I try to reach Infinity? It's recommend to get 2 galaxies before attempting to reach it. On the way there, you should dimension boost as many times as you can.
Each achievement has conditions that must be met before they are earned. Some are very simple, and some are significantly trickier. You may have to infinity or start a challenge before attempting some of the harder ones.
You will receive a x1.5 multiplier to all dimensions for each completed row. In addition, some achievements have their own rewards.
Challenges are unlocked after first infinity; they change in-game mechanics in different ways to create more difficult infinity circumstances.
Each completed challenge will award an auto buyer. You can run them multiple times (though only the first time grants a reward), and they can be exited at any time via the “Exit Challenge” button on the challenge tab.
The rightmost row of Infinity Upgrades does not work in challenges.
Autobuyers:
Autobuyers (awarded by completing challenges) allow the automatic purchase of dimensions, dimension shifts/boosts, galaxies, tickspeed interval decreases, Big Crunches, and Dimensional Sacrifice (later). They are located under the infinity tab in "Autobuyers".
Priority: Priorities tell the game which autobuyer will buy if two are affordable in the same tick. Priority 1 is bought 1st, Priority 2 is bought 2nd, etc. Two equal priorities will pick their buying order randomly.
Autobuyer Speed:The cooloff period before the autobuyer makes another purchase. This rounds up to the nearest 100ms, so 200ms and 101ms are the same speed.
Bulk Buy: Once the Speed of an Autobuyer is maxed, all future upgrades will double the amount the autobuyer purchases per tick. This can be disabled.
Dimension Autobuyer Buy Quantity: Autobuyers for dimensions can be set to buy a single, or until 10, on each cooldown. Bulk buy does not work when the autobuyer is set to singles.
Tickspeed Autobuyer Buy Quantity: The tickspeed autobuyer can be set to buy a single or the max available on each cooldown.
Automatic Dimboost Customization: With the Dimboost autobuyer you can set the max amount of 8th dimensions to use for the autobuyer, the amount of galaxies before dimboosts are always autopurchased, and (when unlocked) the ability to buy dimboosts in bulk (at a fixed amount).
Max Galaxies: The highest amount of galaxies the galaxies autobuyer will buy.
IP on crunch: Once you break Infinity, you can set how many IP you would like to wait for before crunching. It accepts e notation (12.34e5 is 1234000).
Sacrifice Autobuyer: This autobuyer has a maxed timer from the start. You can set how much multiplier it waits for before sacrificing. It accepts e notation.
The double autobuyer tick speed upgrade will have all autobuyers buy twice as fast. Toggle All Autobuyers: This button will turn all of your autobuyers on or off.
Hotkey: A (for toggle all autobuyers)
Originally Antimatter Dimensions was restricted by "Infinity". Since a significant update, you can now "Break Infinity" once your Big Crunch autobuyer has been maxed. This opens up a selection of new upgrades as well as the ability to gain more than 1 infinity point per run.
Fixing Infinity:You can revert the breaking at anytime by clicking fix infinity.
IP Gain Formula:10^(log(current antimatter)/n-0.75)*bonuses, where n is 308 at default, 307.8 with the "This achievement doesn't exist II" achievement, or 290 with the relevant timestudy.
Unlocking Infinity Dimensions:Infinity Dimensions are unlocked by reaching a certain amount of antimatter.
Infinity Dimension Cost:Infinity dimensions are only purchasable in sets of 10, and cost Infinity points.
Infinity Dimension Production:Similar to the original dimensions, each infinity dimension produces the dimension below it. Dimension 3 produce 2, 2 produces 1. Instead of antimatter, Infinity Dimension produces Infinity power, which translates to an overall multiplier on all original dimensions.
Infinity Power gives a boost to all dimensions equal to (power^7).
Infinity Challenges are like regular challenges, but they have higher end goals and are generally harder than regular challenges (but have a different kind of reward).
They unlock at set amounts of antimatter - the ones unlocking later are (generally) more difficult.
Each replicanti has an upgradable chance to update every replicanti tick. You will gain a bonus to infinity dimensions based on how much replicanti you have.
When replicanti reach infinity, you can buy a galaxy. This will not increase the cost of normal galaxies. The amount of replicanti galaxies you can have is capped (upgradable). Once you reach infinity replicanti, they will not continue growing (unless you have the relevant time study).
When offline, in an inactive tab, lagging, or a tickspeed under 50ms, replicanti get calculated with an approximation. This can cause wildly varying results, especially at extremely low numbers (1-5).
When at low values (100-1000) (when none of the conditions above are true), there may be some minor variances in the expected amount of replicanti gain.
Formulas:
Infinity Dimension power increase: log2(replicanti)^2, plus replicanti^0.032 if you have the relevant time study, times 5^galaxies if you have that time study.
Chance upgrade cost:x(1e15) per upgrade
Speed upgrade cost:x(1e10) per upgrade
Galaxy upgrade cost:1e(170+n*25+n^2*5)
Upon reaching infinity Infinity Points, you can eternity. Eternities will reset everything before this point except challenge times, achievements, and total antimatter. You also unlock a new tab.
You can pass infinity Infinity Points whenever. You will receive more Eternity Points the more Infinity Points you had before going Eternal.
EP gain formula: floor(5^(floor(log10(IP))/308-0.7)*bonuses. The x10 EP time study gives the bonus before the outer floor.
To make eternities faster and more convenient, you will unlock various buffs as you get more eternities. These buffs are either making you start with something on eternity or unlock an autobuyer.
For the buffs at the start of an eternity, you will keep the relevant statistic on the run you unlock the milestone. (On 1 > 2, you will keep your autobuyers.)
The last milestone is at 100 eternities and allows full automation.
After your first eternity, you unlock Time Dimensions. You buy them with EP and they provide time shards, which give free tickspeed upgrades (which don't increase the price). These free tickspeed upgrades stay on infinity (applying retroactively to your tickspeed mult through more galaxies).
Similarly to the other dimensions, a Time Dimension 2 produces a Time Dimension 1 and so on.
Each tick threshold takes 33% more time shards than the previous (25% with the relevant time study).
A Time Study is a powerful post-eternity upgrade, which costs Time Theorems. Time Studies are laid out in a tree-like fashion, where you must buy prerequisites before continuing. There are sometimes choices to make with which Time Study to buy, as you cannot get all of them even if affordable.
Time Theorems are a limited resource which costs more for each one you buy. They can be bought with antimatter, infinity points, and eternity points.
Respecs: A Respec allows you to reset the upgrades you have in the tree to retrieve the Time Theorems spent on them. It can be done for free on eternity.
Costs: (1e20000^times bought) for antimatter, (1e100^times bought) for IP, (2^times bought) for EP.
Eternity Challenges are a new type of Challenges where you must eternity at specified amount of IP to finish the challenge. There is a time study that unlocks an Eternity Challenge when bought, called "Eternity Challenge study", but there is a prerequisite for every Eternity Challenge study. Each time you complete an Eternity Challenge, the goal increases and you need to reach bigger prerequisite values to do it again.
Time dilation is unlocked when you purchase the 5,000 TT time study after beating both EC11 and EC12 five times, and after acquiring a total of 13,000 TT. Dilating time will start a new eternity, and all of your Dimension/Infinity/Time Dimension multipliers’ exponents and tickspeed multipliers’ will be reduced to ^0.75.
If you can reach 1.79e308 IP and eternity within a dilated eternity, you are rewarded with Tachyon Particles upon the dilated eternity. You can dilate as many times as you want.
Tachyon Particles generate another currency, Dilated Time. Dilated time is translated into free galaxies by reaching a certain threshold. These galaxies are permanent except when you buy a certain Dilation Upgrade.
Dilation Upgrades are upgrades that are purchasable with Dilated Time. Some upgrades improve the amount of Dilated Time you gain or reset your free galaxies but decrease the threshold required to get to them. In addition, there is also a TT generator as one of the Dilation upgrades. The first row of dilation upgrades is purchasable as many times as possible, but the rest cannot.
Meta Dimensions are a new type of dimensions that resemble Normal Dimensions, but there is no meta-tickspeed and meta-galaxies. They can be unlocked by buying 1e24 TT dilation study. meta-dimension 1 produces meta-antimatter, which makes dimension boosts more powerful. A meta-dimension 2 produces a meta-dimension 1 and so on until the 8th. Unlike Normal Dimensions, resetting meta-dimensions (with meta-dimension shifts/boosts) does not reset anything outside of it. Only meta-dimensions will reset.
Mastery Studies are a new type of Time & Dilation studies, but the cost will rise each time you buy a time study. When you respec, the costs of all time studies will decrease.
You can assign anti-Quarks into 3 colored quarks, which give specific color powers. However, one cancel another one, which will be transformed into anti-gluons on next quantum.
When you reach enough Quantum Energy, you unlock Entangled Boosts, which is based on which kind of anti-gluon you choose. The chosen anti-gluons will also give a bonus to quantum energy. When you progress more, some Entangled Boosts will become mastered and always active.
(THIS WILL BE REWRITTEN SOON)
You can toggle the sacrifice of Meta-Dimension Boosts and Quantum Energy for Positrons, which sacrifice Galaxies for Positronic Charge. Positronic Charge is used for Positronic Boosts, which is like Entangled Boosts, but always active, and work different significantly.
Quantum Challenges is like Infinity Challenges, but they have a different set of goals, including MA goal for each one. They also come with unique quirks and catches that actually change the gameplay.
[WIP] You can combine 2 Quantum Challenges into 1 from the assignable table, which give more rewards on completion. Levelling up allows you to assign more combinations. Completing however increases some other goals, and you can reduce it by completing in other rows.
This section is currently empty. You can write this and I will probably accept it!
You can link between perks to form strong arcs, which require Fluctuant Energy. You can also link a perk with the center for better other perks, or link from the center to activate a perk and nearby ones.


--- layout: default title: "JSConf US 2015 Braintree Track Transcription by NPM" id: track_b_transcription ---


I feel the need to contribute my experience for one, the knowledge of others and two, to better understand my experience with Datura, which occurred about four days ago.
I pretty much broke every rule regarding Datura when I decided to try it. It was my first hallucinogenic experience. I would say I ingested it with no knowledge of how much I should take, but itís hardly possible to know exactly how much is dangerous. My experience wasnít horrible. Looking back, I would try Datura again, but for reasons I canít understand, especially because of how dangerous it is.
My experience happened at my college. The setting where I first ate the seeds is in my friendís dorm room.
My sitter counted the bag of Datura innoxia seeds, which turned out to be 130. To be careful, I decided Iíd eat ten of them raw first and see what happened. The taste wasnít bothersome at all. This was at about 11 oíclock pm. It was irritating to have my sitter ask me every five minutes if I was feeling anything, and, ďWhat if I ate just two of them? Do you think it would do anything?Ē After about two hours no noticeable change had occurred. I then decided Iíd make a tea with some of the seeds. I did that, mixed it with some pomegranate tea, drank the liquid and then ingested the seeds at the bottom of the cup. It tasted normal. I waited, and although I sort of knew that it could take awhile to for any effects to kick in, I got impatient. I ended up eating all 130 of the seeds. This was probably at about 2 AM.
The next thing I remember is my sitter turning the light off and watching a movie on her computer in the bed across the room. I was in her roomateís bed, as her roommate was gone. My friend is done with the movie and decides to go to bed. At this point I was incredibly exhausted, and all I wanted to do was sleep. I toss and turn for quite a long time. I really donít remember if I ever fell asleep in that bed, but I probably didnít because I remember having the biggest urge to go back to my own room. I took my laptop and went back to my room where I fell asleep (Iím assuming I fell asleep) and woke up the next morning.
I donít even know how to begin to explain what was going on when I woke up. I remember looking at a poster next to my bed of my favorite guitarist and feeling like he was staring and laughing at me. I think I was amused by this. Everything seemed real, but at the same time, surreal. I got out of my bed and proceeded to get dressed, but I knocked down my roommates guitar about three times and consequently woke her up as well. I apologized every time. My motor skills were gone.
The next thing I remember is looking in the mirror, which one can imagine as being an insane experience. I remember seeing myself in the mirror, that is, in retrospective, I can see myself in the mirror. But at the time, I thought it was my friend Elyssa. There really is no way to describe what I believed to be happening. I was also talking to her because I really thought that she was in the room, along with other people, except I donít remember who the other people were.
Whatís strange is that when I was on Datura, I really did believe that the people who I was talking to were there, but I specifically remember getting scared and asking my roommate if Elyssa was actually in the room. I would then not see my friends anymore, only to have them return at other times. This happened several times throughout my experience.
The next part of my experience is the gap that I canít really remember. After I woke up and got dressed I walked down to the dining hall. As I was walking down the stairs outside of my dorm, I saw my friend sitting in the grass on a hill. There is no reason why my friend would be sitting in tall grass doing nothing, but nonetheless, I thought she was. I called out to her several times, turned around and started walking, but when I looked back she was gone. I then started talking to a lamppost and asked it if it knew where my friend was, when an actual person started walking towards me. I asked them as well, but they didnít answer and looked at me like I was crazy. There are no lampposts where I was walking, I now realize.
It was parentís weekend, so all the faculty and professors were there. I then remember sitting outside of the dining hall and talking to one of my professors, which makes me scared to go to class everyday. My friend that was with me said I was coherent during that conversation, but during every other conversation I was speaking gibberish. Since then, every time Iím in the dining hall Iím paranoid. Nonetheless, I donít remember what happened in the dining hall or who I talked to.
I donít really remember the rest of that afternoon. My friends tell me that someone brought me to their room saying that I had no idea where I was or what I was doing, but I donít remember seeing that person. I must have then fallen asleep because I remember waking up, smoking a cigarette, and having it disappear. I thought that I kept dropping them. It was so distressful looking for cigarettes that didnít exist. When I woke up I also started talking to my friend online. I have the conversation saved, it was at 3:45pm. I told her all about my experience and I was completely coherent. When I say coherent, I mean what I was saying was understandable but not necessarily grammatically correct:
Me: yeah i smoked cigarettes that didn't even exist, and i was surprised that they jut vanished and i had lots of conversations with people i know but they weren't anymore near me.
The weird part is, during the conversation I also remember talking to her on the phone, only to look at my hand and realize that the phone wasnít there. (Like the cigarettes). Even now I donít understand how I could talk to some people normally and be completely delirious two minutes later.
Thereís so much more to the experience that I canít possibly explain to anyone. I know that most people who try Datura donít want to do it again, but Iím so fascinated with Datura that I canít say that Iíll never do it again. When I tell my friends that Iím thinking about doing it a second time, they always tell me that I ďwasnít happyĒ when I was tripping. It bothers me when people ask me to get some for them. I didnít really know what I was doing, but I did read about it for a month and I think I pretty much got lucky. I think they get the impression from my experience that it was ďfun,Ē like acid, but itís not. Itís just delirious. I donít know the right word to describe how I felt or feel about the experience. Iím glad it happened. I didnít ďenjoyĒ it, it wasnít ďfun,Ē but I feel a strong connection with Datura. I even pinned the bag of seeds with the label on it next to the poster near my bed.
The after effects included not being able to read anything relatively close to my face (my eyes just couldnít focus), a rapid heartbeat, and overall depersonalization. I remember feeling nauseous the night after I was done tripping and going to the bathroom, only to get scared of being in the bathroom alone and leaving immediately. I also rushed to my friend's room to check my heart-rate, which I thought to be abnormally fast. I didnít talk much in the days afterwards. Iím back to ďnormalĒ now, but for some reason Iím avoiding people that had a negative effect on my life now that the experience is over. When the after-effects were present, I was constantly scared that they would never go away and that I'd be diagnosed with hppd.
 I tried Datura because I felt ready for my first hallucinogenic experience and because something told me that everything was going to be okay. Before Datura, Iíve always been scared to venture outside my mind with hallucinogens.
Different Datura plants have different potencies. I ate 130 seeds and nothing went seriously wrong, whereas I have read of people eating 15 and being in serious physical trouble. Datura was relatively good to me. That doesnít mean itís good to everyone.
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.


From here you can register new cars or select a specific car to manage from a list of cars in the system.


| HOME | DOWNLOAD | DOCUMENTATION | FORUM | FAQ |
> Home > Documentation > Localized Spectral Analysis
SHMTDEBIAS(1) SHTOOLS 2.6 SHMTDEBIAS(1)
SHMTDebias
SHMTDebias - Invert for the global power spectrum given a localized multitaper spectrum estimate.
SYNOPSIS
SUBROUTINE SHMTDebias ( MTDEBIAS, MTSPECTRA, LMAX, TAPERS, LWIN, K, NL, LMID, N, TAPER_WT ) REAL*8 MTDEBIAS(2, (LMAX+2)/NL), MTSPECTRA(2, LMAX+1), TAPERS(LWIN+1, K), LMID((LMAX+2)/NL) INTEGER LMAX, LWIN, K, NL, N REAL*8, OPTIONAL TAPER_WT(K)
DESCRIPTION
SHMTDebias will invert for the global power spectrum given a localized multitaper spectrum estimate. This linear inverse problem is inherently underdetermined, and in order to achive a unique solution it is assumed that the global spectrum is constant in bins of width NL, and that the global power spectrum is constant for degrees greater than LMAX. In practice NL should be increased until the global power spectrum is everywhere positive (negative values would be unphysical) and the variances are reasonable. Further details can be found in Wieczorek and Simons (2007). This set of linear equations is solved using the method of singular value decomposition as outlined in Press et al. (1992, pp. 670-672). In particular each value of multitaper spectrum estimate MTSPECTRA(1,:), as well as the corresponding rows of the transformation matrix, is divided by the uncertainties of the estimate MTSPECTRA(2,:). The solution and uncertainty are given by eqs 15.4.17 and 15.4.19 of Press et al. (1992, p. 671), respectively.
ARGUMENTS
MTDEBIAS (output) REAL*8, DIMENSION (2, (LMAX+2)/NL) The global power spectrum (column 1) and uncertainty (column 2). The midpoints of the N spherical harmonic bins are given in LMID. MTSPECTRA (input) REAL*8, DIMENSION (2, LMAX+1) The localized multitaper spectrum estimate and uncertainty, obtained from a routine such as SHMultitaperCSE or SHMultitaperSE. LMAX (input) INTEGER The spherical harmonic bandwidth of the localized multitaper spectrum estimates. TAPERS (input) REAL*8, DIMENSION (LMAXT+1, K) An array of the K windowing functions, arranged in columns, obtained from a call to SHReturnTapers. LWIN (input) INTEGER The spherical harmonic bandwidth of the windowing functions in the array TAPERS. K (input) INTEGER The number of tapers to be utilized in performing the multitaper spectral analysis. NL (input) INTEGER The global power spectrum is assumed to be constant within bins of spherical harmonic wdith NL. In addition, the global power spectrum will be assumed to be constant beyond LMAX. LMID (output) REAL*8, DIMENSION ( (LMAX+2)/NL ) The midpoints of the spherical harmonic bins for which the global power spectrum is constant. N (output) INTEGER The number of bins used in MTDEBIAS and LMID. TAPER_WT (input) REAL*8, OPTIONAL, DIMENSION (K) The weights used in calculating the multitaper spectral estimates. Optimal values of the weights (for a known global power spectrum) can be obtained from the routine SHMTVarOpt.
NOTES
If TAPER_WT is not specified, the weights will all be assumed to be equal to 1/K.
SEE ALSO
shmultitaperse(1), shmultitapercse(1), shreturntapers(1), shmtvaropt(1) <http://www.ipgp.jussieu.fr/~wieczor/SHTOOLS/SHTOOLS.html>
REFERENCES
Press, W.H., S.A. Teukolsky, W.T. Vetterling, and B.P. Flannery, Numerical Recipes in FORTRAN: The Art of Scientific Computing, 2nd ed., Cambridge Univ. Press, Cambridge, UK, 1992. Wieczorek, M. A., and F. J. Simons, Minimum variance multitaper spectral estimation on the sphere, submitted to J. Fourier Anal. Appl., submitted 2006.
COPYRIGHT AND LICENSE
Copyright 2005, 2006 by Mark Wieczorek<EMAIL_ADDRESS>This is free software; you can distribute and modify it under the terms of the revised BSD license. SHTOOLS 2.6 2009-08-18 SHMTDEBIAS(1)
> Home > Documentation > Localized Spectral Analysis
| Centre National de la Recherche Scientifique | Institut de Physique du Globe de Paris | © 2011 Mark Wieczorek |


Documenting lesser-known features in Ruby
2013 + 2015
2nd Place in 2015 by Shinichiro Hamaji
begin with an easy program.
you should be able to write
a program unless for you,
program in ruby language is
too difficult. At the end
of your journey towards the
ultimate program; you must
be a part of a programming
language. You will end if
you != program
4th Place in 2015 by Benoit Daloze
1st Place in 2013 by kinaba
1st Place in 2015 by kinaba


Doing business
Internet Cafe
For your computer related services
Uvea I. S.
Synergetix
- business startup resources and business consultations
KLS Personnel Services
Melody Lane Catering
RSM accounting
CPTC RacePlex
Are you hungry and looking for social
entertainment?
Perhaps you would enjoy a movie?
Would you be interested in living here?
Are you in need of some legal or
insurance?
Would you enjoy a day at the beach?
How about travelling?
Back to the [Main drag]


--- layout: tweet ---
PDX ✈ SLC ✈ CVG See you soon @rubyconf!
11/8/2016, 5:56:19 AM
Favs: 1
Retweets: 0
... and hello Cincinnati!
11/8/2016, 1:35:32 PM
Favs: 0