| Reinforcement Learning and
Artificial
Intelligence (RLAI) |
|
| Tile
Coding Software |
Tile coding is the key distinguishing computational idea behind CMACs. Implementations of complete CMACs are available from the folks at the University New Hampshire here. Their package is more suited to straight, bundled CMAC use. Here we separate tile coding from full CMACs, which allows it to be more flexibly used, e.g., with eligibility traces. The current software is also simplified and streamlined consistent with its use in reinforcement learning applications. For example, our code is only a few pages in length and there is just one routine to call. In its normal use that routine has no memory and requires no special setup or data types.
This version 2.0 of the tiling software provides an alternate version of the main routine that is "safe" in that it corrects for all hashing collisions, so as to exactly simulate infinite tilings (until it runs out of memory). This version can also be used to gather statistics on hashing collisions even if they are be ignored (as in the standard version). The alternate version requires that an additional hashing table be passed in, and there is greater computational expense.
Next we describe the use of the tile coding routine. This
description applies to both the C and LISP implementations except that
some of the data handling is a little
simpler in LISP. Mostly we assume we are talking about C; the
simplifications for
LISP users are summarized here.
The C++ code assumes the existence of a function "rand()" that produces
successive psuedorandom integers, of which only the low-order bytes are
used. Recently we have added a Python
version which has not yet been extensively tested.
The tile coding software provides a single routine, "tiles
":
void tiles(
int tiles[], // provided array will contain the returned tile indices
int num_tilings, // number of tile indices to be returned
int memory_size, // total number of possible tiles
float floats[], // array of floating-point vars to be converted to tiles
int num_floats, // number of floating-point variables
int ints[], // array of integer variables to be converted to tiles
int num_ints) // number of integer variables
The overall idea here is as follows. The first argument (tiles
)
is the output of the routine. This array is provided by the caller and
filled up by tiles
with tile indices (integers in [0,memory_size
)).
The second argument is the number of tile indices returned, so the
provided
array had better be of at least this length. It is recommended by
the folks at UNH (who designed the key algorithm here) that num_tilings
be a power of two.
Next, memory_size
specifies the largest permitted
tile
index.
The next two arguments are the primary
inputs to tiles
. They specify the floating-point
variables which are to be tiled, in an array, with an accompanying
integer argument to indicate the length of the array.
The routine will overlay grid-tilings on these variables, generalizing
across values that differ by less than 1.0.
The last two arguments are optional. For each different
value of the num_ints
integers in ints
, the
tiles will be hashed totally differently, such that there
is no generalization to any other value of the integers. These
inputs are often used to ensure different hashings for
different groups of tilings, e.g., for different actions in
reinforcement learning.
There are some illustrative examples below.
Alternatively, if there are three such integers or less, they can be
provided as simple integer arguments to tiles
(in
place of the
last two arguments as described above). These cases will be intercepted
by a specialized version of tiles
, the integers packed
into an
array automatically, and finally the base version of tiles
,
as described above, will be called. There is a similar shortcut for the
case
with one or two floating-point variables, described below.
Next we describe examples, gradually increasing in complexity, of the use of the tiles routine.
tiles
assumes unit generalization in its inputs, so we arrange for .25
generalization by scaling x and y and stuffing the
results into a float array float_array
to be input to tiles:
float float_array[2];
float_array[0] = x / 0.25;
float_array[1] = y / 0.25;
Despite this fairly
broad generalization, we would like the ability to make fine
distinctions if required.
For this we need many tilings, say 32 (a power of two is good here).
This will give us an ultimate resolution of .25/32=.0078, or better
than 1%.
To arrange for this we pass the tiles routine an integer array, tiles_array
,
of at least 32 elements, to hold the returned
results, and pass 32 as the num_tilings
argument.
int tiles_array[32];
Finally, we have to select memory_size
, the range
of tile indices that will be hashed down into. First we consider the
"natural" memory size, as if we were doing no hashing. This is simply
the total number of tiles in all the tilings,
or 4*4*32=512 in our case. This is not a large number and might be used
directly as the memory_size
.
Note, however, that this does not mean there will be no hashing or hash
collisions.
This routine always hashes and so collisions are possible. You could
make them very unlikely
by using a large memory size, say 5120, or even 512000 if you have
enough memory for
how the tiles are to be used. More often the natural memory size is too
large, say 10^10, and we must hash into a smaller memory size.
Thus, our final call to tiles
routine might be
tiles(tiles_array,32,512,float_array,2);
The returned tiles can be used in many ways, as is discussed elsewhere. But let
us complete this simple example by showing one use. To do simple linear
function approximation
one uses an array of weights of number equal to the total number of
possible tiles
(memory_size
).
The approximate function value for the input vector of real values is
obtained
simply by summing the weights of the corresponding returned tiles:
float weights[512];
float result = 0.0;
for (i=0;i<32;i++) \
result += weights[tiles_array[i]];
target
that
we wish to adjust the approximation result towards:
float target;
float alpha = 0.1 / 32; // step-size parameter
for (i=0;i<32;i++) \\
weight[tiles_array[i]] += alpha * (target - result);
For simple uses of tiles
, packing into arrays
is
tiresome,
so we provide routines to do the packing for you for the cases
with 1 or 2 floating-point state variables, called tiles1
and tiles2
.
For example, the 4x4 grid case described above could be done without
explicitly
packing into the float_array
by calling
tiles2(tiles_array,32,512,x/0.25,y/0.25);
There are a number of useful simple variations on the example
described
above.
Obviously, one could scale the two dimensions differently to get
rectangular
rather than square tiles. One could also stretch and distort the
dimensions, for example,
making one logarithmic. Or one could obtain a rotated grid by linear
transformations
on the original x and y variables. For example, to get
a grid oriented along the diagonals, we construct the float_array
like this:
float_array[0] = (x+y) / 0.25;
float_array[1] = (x-y) / 0.25;
Note that the tiling produced in all these cases is not
restricted to
any region of
the space. It extends in all directions to infinity; it is a tiling of
the infinite
plane. These infinite number of tiles are reduced to memory_size
in number
by the hashing.
If you want to restrict the input vector to a limited region,
then
you must do so
yourself before calling tiles
. If you want to achieve
a wrap-around
effect, then you should cause wrap-around when you construct the float_array
,
e.g., by dividing by the width of the region and filling float_array
with the remainder.
Sometimes one can get by with a single kind of tiling, as
produced by a
single call
to tiles
(note that a single call creates multiple
tillings, but these are
all simple offset copies of each other). But for many other cases one
needs to be a little more sophisticated.
A great deal can be done to control the generalization and to limit the
memory requirements
by using multiple tilings through multiple calls to tiles
.
We consider some of
these below.
Suppose as previously you have input vectors in the unit square,
but
you want to generalize
between input vectors that are similar along the x dimension OR
similar along the y
dimension. To do this you need two kinds of tilings, one
producing stripes horizontally and one vertically. Suppose you want to
make 32 tilings of each type, and combine the results
in one 64-element tiles_array
:
int tiles_array[64];
tiles1(tiles_array,32,4*32*2,x/0.25,0);
tiles1(&tiles_array[32],32,4*32*2,y/0.25,1);
tiles
passes in, in effect, the
second half of the full tiles_array
. The tiles from the
second group of tilings will go there. Notice that the memory_size
input
is the same for both calls and set roughly equal to the memory
requirements for both
sets of tiles: 4 (stripes over the unit interval) * 32 (number of
tilings within a stripe) * 2
(because there are two sets of tilings over this memory space). As
always, the memory_size
can be chosen within wide limits,
but it makes sense to chose it the same for all the groups of
tilings. Finally, notice that we change the final
integer input from 0 to 1 in the second call. Whenever using multiple
calls like this, it is a good idea to give them each a different
setting for the integer arguments.
There are a lot of possibilities here. One could use two groups of tilings, one for each single dimension, as illustrated above, PLUS an additional group of tilings that depends on both dimensions. This would create a system that generalizes partly along each dimension separately, but also on the two dimensions conjunctively, so that it could if needed learn to give a special response to a particular pair of x,y values. Another possibility would be to choose some groups of tilings with coarse generalization and some with fine.
One can control the tendency to generalize in the different ways given by each group of tilings by controlling the number of tilings in each group. For example, if you wanted discrimination to be stronger along x rather than y, then you would ask for more x tillings (more than 32) in the above example, or fewer y tilings.
In many applications one wants to make sure hashing, a random process, is done in a consistent way, e.g., across different runs of a program. The hashing done by the routines described here is determined by some tables filled with random numbers the first time the routine is called. To get consistent hashing you need only ensure that the random number generator is in a consistent state for the first call. A convenient way to do this is to make a dummy first call during an initialization portion of your program. For example, an early portion of your C++ code could include:
int dummy_tiles[1];
float dummy_vars[1];
srand(0);
tiles(dummy_tiles,1,1,dummy_vars,0); // initializes tiling code
*random-state*
in
a reproducable manner, then call (tiles nil 1 1)
.random.seed(number)
, and then import the
tiles
module.The LISP function "tiles
" returns a list of
tile
indices. It is called as follows:
(tiles
num-tilings ; the number of tilings desired
memory-size ; the number of possible tile indices
floats ; a list of real values making up the input vector
ints) ; optional list of integers to get different hashings
All the inputs have the same meanings and uses as described above.
Multiple calls
are combined by appending (or nconcing) the resultant lists into one
list.
The function "load-tiles
" is also available as a
maximally efficient interface.
It loads a portion of a provided array with the returned tile indices.
It is called as follows:
(load-tiles
tiles ; a provided array for the tile indices to go into
starting-element ; first element of "tiles" to be changed (typically 0)
num-tilings ; the number of tilings desired
memory-size ; the number of possible tile indices
floats ; a list of real values making up the input vector
ints) ; list of optional inputs to get different hashings
The Python function "tiles
" returns a tuple of
tile
indices. It is called as follows:
tiles(numtilings, memsize, floats, ints)
All the inputs have the same meanings and uses as described above.
Multiple calls
are combined by concatenating the resultant tuples into one.
The function "loadtiles
" is also available as a
maximally efficient interface.
It loads a portion of a provided array with the returned tile indices.
It is called as follows:
loadtiles(tiles, startelement, numtilings, memsize, floats, ints)
with meanings as in the lisp calls.
In order to improve the efficiency of the tiling functions, but
still have the flexibility of
Python, there is also a version available for Python which calls the C
version of tiles. The calling
sequences are exactly the same as for the Python versions, although the
module is loaded from a different location (e.g. CTiles.tiles instead
of RLtoolkit.tiles).
With the code described so far, there is a small probability that unrelated inputs will hash into some of the same tiles. In a group of tilings, usually there will be no more than one such "collision", so that it is not a big problem; the learning process will sort it out. There will not be a big effect on performance unless the memory is too small or the hash functions are poorly designed. Nevertheless, the possibility of such a problem is annoying. When one's program doesn't work, there is a tendency, deserved or not, to suspect a failure of the hashing function.
To alleviate this kind of concern, we provide another "safe"
version
of the routine that
does the additional work to prevent hashing collisions -- or rather to
detect them and
take the necessary corrective steps. The result is a guaranteed exact
emulation
of the infinite tilings. Every different tile used will have a
different index. If more tiles are used than there is space within the memory_size
,
then an error
is signaled. Of course there is also a cost in terms of additional
memory and computation.
The additional memory is contained in an additional data structure, called a "collision table". To create and use a collision table in the original 4x4 example:
collision_table ct(512,1);
float float_array[2];
int tiles_array[32];
float_array[0] = x / 0.25;
float_array[1] = y / 0.25;
tiles(tiles_array,32,&ct,float_array,2);
In the declaration of the collision table, the 512 is the size of the
table. The size must be a power of two. The 1 in the declaration
indicates that this is to be a "safe" table; provide a 0 here if you
just
want to collect statistics on a regular table. Notice that the
collision
table is then used in place of the memory_size
in calls
to tiles
.
This is possible because of course the collision table has the memory_size
stored within it.
You can call ct.usage()
to determine how many
entries
in the table
are currently in use. You can also examine ct.calls
, ct.clearhits
,
and ct.collisions
to determine the number of times this
collision
table has been used (calls), has returned a result without a collision
(clearhits),
and has had collisions (collisions, which may be more than one per
call).
ct.reset
clears the collision table, making room
for a
new set of entries.
In Lisp, you construct a collision-table by calling make-ct
:
(make-ct
memory-size ; the number of possible tile
indices
safety-level) ; one of :safe, :unsafe, or
:super-safe
which returns the newly initialized collision-table.
The memory-size
here must be a power of two, e.g., 1024;
otherwise it is
the same memory-size
as before. If the safety-level
is :unsafe
, then
the collision table is used only to collect statistics; collisions are
still allowed
and not corrected for. Normally, a safety-level
of :safe
is adequate, but :super-safe
is available to be
absolutely sure.
Once a collision table has been constructed, it is used in any
of
the routines
previously described simply by passing it in in place of the memory-size
input to the routine. For example, a lisp version of the 32 4x4 tilings
example, using the
safe version, would look
like
this:
(setq ctable (make-ct 512 :safe)) ; this is done once
(tiles 32 ctable (list (/ x .25) (/ y .25))) ; done for each x,y
In Python, you obtain a CollisionTable by calling CollisionTable(memsize,
safetyval)
, with meanings as above except safetyval
is one of 'safe', 'unsafe', or 'super safe'.
Once a collision table has been constructed, it is used in any of the
routines
previously described simply by passing it in in place of the memsize
input to the routine. For example, a python version of the 32 4x4
tilings example,
using the safe version, would
look like this:
ctable = CollisionTable(512, 'safe') # this is done once
tiles(32, ctable, (x/0.25, y/0.25)) # this is done for each x,y
The version where Python calls C does not have the 'super safe'
collision table options, since it has not been implemented in the C
version (the required comparisons would slow things down considerably).The tilings we have discussed so far stretch out to infinity with no need to specify a range for them. This is cool, but sometimes not what you want. Sometimes you want the variables to wrap-around over some range. For example, you may have an angle variable that goes from 0 to 2pi and then should wrap around, that is, you would like generalization to occur between angles just greater than 0 and angles that are nearly 2pi. To accomodate this, we provide some alternative, wrap-around versions of the tiling routines.
These versions take an additional input, wrap-widths
,
which parallels the float structure (array or list), and which
specifies for each float the width of the range over which it wraps
(e.g., 2pi). If you don't want a float to wrap, it's wrap-width should
be zero (in LISP, nil). The wrapping width is in the same units as the
floats, but should be an integer. Specifying the complete range of
wrapping (rather than just the width) is not necessary for the same
reason we did not need to give a range at all in the previous routines.
For example, suppose you wanted to cover the 2pi x 3 rectangular area with 16 tilings, each with a width of generalization one-tenth of the space in each dimension, and with wrap-around in the first dimension but not the second. In C you would do
int tiles_array[16];
float float_array[2];
int wrap_array[2];
float_array[0] = x / (3 * 0.1);
wrap_array[0] = 0;
float_array[1] = y / (2 * 3.14159 * 0.1);
wrap_array[1] = 10;
tileswrap(tiles_array,16,512,float_array,2,wrap_array);
tileswrap
has the interface:
void tileswrap(
int tiles[], // provided array will contain the returned tile indices
int num_tilings, // number of tile indices to be returned
int memory_size, // total number of possible tiles
float floats[], // array of floating-point vars to be converted to tiles
int num_floats, // number of floating-point variables
int wrap_widths[], // array of widths (length and units as in floats)
int ints[], // array of integer variables to be converted to tiles
int num_ints) // number of integer variables
Previous C versions had a bug because of an oddity of
the C
mod function, but this has been fixed.
In LISP, the wrapping routines are:
(tiles-wrap
num-tilings ; the number of tilings desired
memory-size ; the number of possible tile indices
floats ; a list of real values making up the input vector
wrap-widths ; list of widths for wrap-around on floats (ints or nil)
ints) ; optional list of integers to get different hashings
and
(load-tiles-wrap
tiles ; a provided array for the tile indices to go into
starting-element ; first element of "tiles" to be changed (typically 0)
num-tilings ; the number of tilings desired
memory-size ; the number of possible tile indices
floats ; a list of real values making up the input vector
wrap-widths ; list of widths for wrap-around on floats (ints or nil)
ints) ; list of optional inputs to get different hashings
In Python (and the Python calling C version), the wrapping routines
are:
tileswrap(numtilings,
memsize, floats, wrapwidths, ints)
loadtileswrap(tiles, startelement, numtilings, memsize, floats,
wrapwidths,
ints)


Start Over
Active Transport, Adaptation, Animalia, Biosphere, Cell, Dependent Variable, Eukarya, Evolution, Excretion, Hypothesis, Natural Selection, Organelle, Producers, Prokaryotic Cell, Respiration, Species, Virus


Solaris SVM usage step by step
Notes: need create svm env for Prod patch test. actually zfs is much convinent now. still the requirement issue. we can’t take advantage of zfs in Solaris 9/8
Step 1.
create VM with 2 drives. c0t0d0 & c0t1d0
Step 2.
Duet to hardware limit, we use x86, Install Solaris 10 with option 4. install with Text console. we install OS on one disk
Step 3.
Create SVM
3.1 create the same disk layout as rootdisk,
| prtvtoc /dev/rdsk/c0t0d0s2 | fmthard -s – /dev/rdsk/c0t1d0s2 |
3.2 initialize the metadb, depends the layout you have. choose two slice for the meta store.
metadb -a -f -c 2 c0t0d0s3 c0t1d0s3
metadb
flags first blk block count
a m p luo 16 8192 /dev/dsk/c0t0d0s3
a p luo 16 8192 /dev/dsk/c0t1d0s3
3.3 install grub to the s0 for / ? (maybe not nessary to solaris 10)
installgrub /boot/grub/stage1 /boot/grub/stage2 /dev/rdsk/c0t1d0s0
3.4 create mirror for /
# metainit -f d10 concat/stripe numstripes slice
metainit -f d10 1 1 c0t0d0s0
metainit -f d20 1 1 c0t1d0s0
# metainit mirror -m submirror
metainit d0 -m d10
# create root on the mirror, this will update /etc/vfstab and /etc/system let the boot use d0
metaroot d0
3.5 after that reboot — -r, then attach d20 to the mirror.
metattach d0 d20
3.6. do the same on /var
Issue and tips;
# mount cd on solaris
iostate -En #get the cdrom
mount -F hsfs -o ro /dev/dsk/c1t0d0s0 /mnt
or
mount -F hsfs -r /dev/sr0 /mnt
# swap off the swap device
swap -d /dev/dsk/c0t0d0sx


Raven
Determined
by
T.P.
Ramamo˜rthy
Missouri
Botanical
Garden
L.
M.
UNDERWOOD
&
F.
S.
EARLE,
COLLECTORS
MARCH,
I9O3
Philip
A.
Munz
01447492
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


|
Pallas Solver
0.1
C++ Global Optimization Algorithms
|
#include <differential_evolution.h>
Public Member Functions | |
| Options () | |
| Default constructor. More... | |
Public Attributes | |
| GradientLocalMinimizer::Options | local_minimizer_options |
| MutationStrategyType | mutation_strategy |
| CrossoverStrategyType | crossover_strategy |
| PopulationInitializationType | population_initialization |
| unsigned int | max_iterations |
| unsigned int | population_size |
| double | minimum_cost |
| Vector2d | dither |
| Vector | upper_bounds |
| Vector | lower_bounds |
| double | crossover_probability |
| double | tolerance |
| bool | polish_output |
| bool | is_silent |
| unsigned int | history_save_frequency |
Configurable options for modifying the default behaviour of the differential evolution algorithm.
|
inline |
Default constructor.
This tries to set up reasonable defaults for optimization. It is highly recommended that the user read and overwrite the defaults based on the cost function.
| double pallas::DifferentialEvolution::Options::crossover_probability |
The recombination constant, should be in the range [0, 1]. Increasing this value allows a larger number of mutants to progress into the next generation, but at the risk of population stability.
| CrossoverStrategyType pallas::DifferentialEvolution::Options::crossover_strategy |
The crossover strategy to use. Should be one of BINOMIAL
or EXPONENTIAL
.
| Vector2d pallas::DifferentialEvolution::Options::dither |
It should be in the range [0, 2]. Dithering randomly changes the mutation constant on a generation by generation basis. The mutation constant for that generation is taken from U[min, max). Dithering can help speed convergence significantly. Increasing the mutation constant increases the search radius, but will slow down convergence.
| unsigned int pallas::DifferentialEvolution::Options::history_save_frequency |
Frequency to save the state of the system. Values will be appended to a HistorySeries
contained in the optimization summary. Default is 0. If 0 then history is not saved. Otherwise, the state of the system will be appended to the series when i % history_save_frequency == 0
. If there are a large number of iterations this can lead to a lot of data being stored in memory.
| bool pallas::DifferentialEvolution::Options::is_silent |
Whether to log failure information relating the to global optimization algorithm using glog.
| GradientLocalMinimizer::Options pallas::DifferentialEvolution::Options::local_minimizer_options |
Contains any changes to the default options for the local minimization algorithm. See the documentation for ceres::GradientProblemSolver::Options for relevant options
| Vector pallas::DifferentialEvolution::Options::lower_bounds |
Lower bounds for variables
| unsigned int pallas::DifferentialEvolution::Options::max_iterations |
The maximum number of times the entire population is evolved.
| double pallas::DifferentialEvolution::Options::minimum_cost |
User specified minimum cost. Minimization will halt if minimum_cost
is reached.
| MutationStrategyType pallas::DifferentialEvolution::Options::mutation_strategy |
The mutation strategy to use. Should be one of BEST_1
, RAND_1
, RAND_TO_BEST_1
, BEST_2
, or RAND_2
.
| bool pallas::DifferentialEvolution::Options::polish_output |
Whether the global minimum found through differential evolution should be subjected to a local minimization "polishing" step before returning the result.
| PopulationInitializationType pallas::DifferentialEvolution::Options::population_initialization |
Specify how the population initialization is performed. Should be one of: LATIN_HYPERCUBE
or RANDOM
. The default is LATIN_HYPERCUBE
. Latin Hypercube sampling tries to maximize coverage of the available parameter space. RANDOM
initializes the population randomly - this has the drawback that clustering can occur, preventing the whole of parameter space being covered.
| unsigned int pallas::DifferentialEvolution::Options::population_size |
The total number of individuals in the population.
| double pallas::DifferentialEvolution::Options::tolerance |
When the mean of the population energies, multiplied by tolerance, divided by the standard deviation of the population energies is greater than 1 the solving process terminates: convergence = mean(pop) * tol / stdev(pop) > 1
.
| Vector pallas::DifferentialEvolution::Options::upper_bounds |
Upper bounds for variables.


How to Contribute
I would be very happy about any kind of contributions that help to improve and extend the functionality of mlearner.
Quick Contributor Checklist
This is a quick checklist about the different steps of a typical contribution to mlearner (and other open source projects). Consider copying this list to a local text file (or the issue tracker) and checking off items as you go.
- [ ] Open a new "issue" on GitHub to discuss the new feature / bug fix
- [ ] Fork the mlearner repository from GitHub (if not already done earlier)
- [ ] Create and check out a new topic branch (please don't make modifications in the master branch)
- [ ] Implement the new feature or apply the bug-fix
- [ ] Add appropriate unit test functions in
mlearner/*/tests
- [ ] Run
PYTHONPATH='.' pytest ./mlearner -sv
and make sure that all unit tests pass - [ ] Check for style issues by running
flake8 ./mlearner
(you may want to runpytest
again after you made modifications to the code) - [ ] Add a note about the modification/contribution to the
./docs/sources/changelog.md
file - [ ] Modify documentation in the appropriate location under
mlearner/docs/sources/
- [ ] Push the topic branch to the server and create a pull request
- [ ] Check the Travis-CI build passed at https://travis-ci.org/rasbt/mlearner
- [ ] Check/improve the unit test coverage at https://coveralls.io/github/rasbt/mlearner
- [ ] Check/improve the code health at https://landscape.io/github/rasbt/mlearner
Tips for Contributors
Getting Started - Creating a New Issue and Forking the Repository
- If you don't have a GitHub account, yet, please create one to contribute to this project.
- Please submit a ticket for your issue to discuss the fix or new feature before too much time and effort is spent for the implementation.
- Fork the
mlearner
repository from the GitHub web interface.
- Clone the
mlearner
repository to your local machine by executinggit clone https://github.com/<your_username>/mlearner.git
Syncing an Existing Fork
If you already forked mlearner earlier, you can bring you "Fork" up to date with the master branch as follows:
1. Configuring a remote that points to the upstream repository on GitHub
List the current configured remote repository of your fork by executing
$ git remote -v
If you see something like
origin https://github.com/<your username>/mlearner.git (fetch)
origin https://github.com/<your username>/mlearner.git (push)
you need to specify a new remote upstream repository via
$ git remote add upstream https://github.com/jaisenbe58r/MLearner.git
Now, verify the new upstream repository you've specified for your fork by executing
$ git remote -v
You should see following output if everything is configured correctly:
origin https://github.com/<your username>/mlearner.git (fetch)
origin https://github.com/<your username>/mlearner.git (push)
upstream https://github.com/jaisenbe58r/MLearner.git (fetch)
upstream https://github.com/jaisenbe58r/MLearner.git (push)
2. Syncing your Fork
First, fetch the updates of the original project's master branch by executing:
$ git fetch upstream
You should see the following output
remote: Counting objects: xx, done.
remote: Compressing objects: 100% (xx/xx), done.
remote: Total xx (delta xx), reused xx (delta x)
Unpacking objects: 100% (xx/xx), done.
From https://github.com/jaisenbe58r/MLearner
* [new branch] master -> upstream/master
This means that the commits to the rasbt/mlearner
master branch are now
stored in the local branch upstream/master
.
If you are not already on your local project's master branch, execute
$ git checkout master
Finally, merge the changes in upstream/master to your local master branch by executing
$ git merge upstream/master
which will give you an output that looks similar to
Updating xxx...xxx
Fast-forward
SOME FILE1 | 12 +++++++
SOME FILE2 | 10 +++++++
2 files changed, 22 insertions(+),
*The Main Workflow - Making Changes in a New Topic Branch
Listed below are the 9 typical steps of a contribution.
1. Discussing the Feature or Modification
Before you start coding, please discuss the new feature, bugfix, or other modification to the project on the project's issue tracker. Before you open a "new issue," please do a quick search to see if a similar issue has been submitted already.
2. Creating a new feature branch
Please avoid working directly on the master branch but create a new feature branch:
$ git branch <new_feature>
Switch to the new feature branch by executing
$ git checkout <new_feature>
3. Developing the new feature / bug fix
Now it's time to modify existing code or to contribute new code to the project.
4. Testing your code
Add the respective unit tests and check if they pass:
$ PYTHONPATH='.' pytest ./mlearner ---with-coverage
5. Documenting changes
Please add an entry to the mlearner/docs/sources/changelog.md
file.
If it is a new feature, it would also be nice if you could update the documentation in appropriate location in mlearner/sources
.
6.  Optional: squashing commits
If you made multiple smaller commits, it would be nice if you could group them into a larger, summarizing commit. First, list your recent commit via
Note
Due to the improved GitHub UI, this is no longer necessary/encouraged.
$ git log
which will list the commits from newest to oldest in the following format by default:
commit 046e3af8a9127df8eac879454f029937c8a31c41
Author: rasbt<EMAIL_ADDRESS>Date: Tue Nov 24 03:46:37 2015 -0500
fixed setup.py
commit c3c00f6ba0e8f48bbe1c9081b8ae3817e57ecc5c
Author: rasbt<EMAIL_ADDRESS>Date: Tue Nov 24 03:04:39 2015 -0500
documented feature x
commit d87934fe8726c46f0b166d6290a3bf38915d6e75
Author: rasbt<EMAIL_ADDRESS>Date: Tue Nov 24 02:44:45 2015 -0500
added support for feature x
Assuming that it would make sense to group these 3 commits into one, we can execute
$ git rebase -i HEAD~3
which will bring our default git editor with the following contents:
pick d87934f added support for feature x
pick c3c00f6 documented feature x
pick 046e3af fixed setup.py
Since c3c00f6
and 046e3af
are related to the original commit of feature x
, let's keep the d87934f
and squash the 2 following commits into this initial one by changes the lines to
pick d87934f added support for feature x
squash c3c00f6 documented feature x
squash 046e3af fixed setup.py
Now, save the changes in your editor.  In this case, we could enter support for feature x
to summarize the contributions.
8. Uploading changes
Push your changes to a topic branch to the git server by executing:
$ git push origin <feature_branch>
9. Submitting a pull request
Go to your GitHub repository online, select the new feature branch, and submit a new pull request:
Notes for Developers
Building the documentation
The documentation is built via MkDocs; to ensure that the documentation is rendered correctly, you can view the documentation locally by executing mkdocs serve
from the mlearner/docs
directory.
For example,
~/github/mlearner/docs$ mkdocs serve
1. Building the API documentation
To build the API documentation, navigate to mlearner/docs
and execute the make_api.py
file from this directory via
~/github/mlearner/docs$ python make_api.py
This should place the API documentation into the correct directories into the two directories:
mlearner/docs/sources/api_modules
mlearner/docs/sources/api_subpackes
2. Editing the User Guide
The documents containing code examples for the "User Guide" are generated from IPython Notebook files. In order to convert a IPython notebook file to markdown after editing, please follow the following steps:
- Modify or edit the existing notebook.
- Execute all cells in the current notebook and make sure that no errors occur.
- Convert the notebook to markdown using the
ipynb2markdown.py
converter
~/github/mlearner/docs$ python ipynb2markdown.py --ipynb_path ./sources/user_guide/subpackage/notebookname.ipynb
Note
If you are adding a new document, please also include it in the pages section in the mlearner/docs/mkdocs.yml
file.
3. Building static HTML files of the documentation
First, please check the documenation via localhost (http://<IP_ADDRESS>:8000/):
~/github/mlearner/docs$ mkdocs serve
Next, build the static HTML files of the mlearner documentation via
~/github/mlearner/docs$ mkdocs build --clean
To deploy the documentation, execute
~/github/mlearner/docs$ mkdocs gh-deploy --clean
4. Generate a PDF of the documentation
To generate a PDF version of the documentation, simply cd
into the mlearner/docs
directory and execute:
python md2pdf.py
Uploading a new version to PyPI
1. Creating a new testing environment
Assuming we are using conda
, create a new python environment via
$ conda create -n 'mlearner-testing' python=3 numpy scipy pandas
Next, activate the environment by executing
$ source activate mlearner-testing
2. Installing the package from local files
Test the installation by executing
$ python setup.py install --record files.txt
the --record files.txt
flag will create a files.txt
file listing the locations where these files will be installed.
Try to import the package to see if it works, for example, by executing
$ python -c 'import mlearner; print(mlearner.__file__)'
If everything seems to be fine, remove the installation via
$ cat files.txt | xargs rm -rf ; rm files.txt
Next, test if pip
is able to install the packages. First, navigate to a different directory, and from there, install the package:
$ pip install mlearner
and uninstall it again
$ pip uninstall mlearner
3. Deploying the package
Consider deploying the package to the PyPI test server first. The setup instructions can be found here.
$ python setup.py sdist bdist_wheel upload -r https://testpypi.python.org/pypi
Test if it can be installed from there by executing
$ pip install -i https://testpypi.python.org/pypi mlearner
and uninstall it
$ pip uninstall mlearner
After this dry-run succeeded, repeat this process using the "real" PyPI:
$ python setup.py sdist bdist_wheel upload
4. Removing the virtual environment
Finally, to cleanup our local drive, remove the virtual testing environment via
$ conda remove --name 'mlearner-testing' --all
5. Updating the conda-forge recipe
Once a new version of mlearner has been uploaded to PyPI, update the conda-forge build recipe at https://github.com/conda-forge/mlearner-feedstock by changing the version number in the recipe/meta.yaml
file appropriately.


What is the largest value in this list of numbers?
arrValues
theAnswer
Choose something between 0 and index lastIndex
This problem is really too easy for a second hint


public class AdapterTraceMonitor extends Monitor implements AdapterMonitor
| Constructor and Description |
|---|
AdapterTraceMonitor() |
| Modifier and Type | Method and Description |
|---|---|
java.lang.String |
onError(ActivityRuntimeContext runtimeContext,
java.lang.Throwable t)
Called when an error is encountered.
|
java.lang.Object |
onInvoke(ActivityRuntimeContext runtimeContext,
java.lang.Object request,
java.util.Map<java.lang.String,java.lang.String> headers)
Called after onRequest(), but before the service is actually invoked.
|
java.lang.Object |
onRequest(ActivityRuntimeContext runtimeContext,
java.lang.Object request,
java.util.Map<java.lang.String,java.lang.String> headers)
Called when the request is created.
|
java.lang.Object |
onResponse(ActivityRuntimeContext runtimeContext,
java.lang.Object response,
java.util.Map<java.lang.String,java.lang.String> headers)
Called when the response is received.
|
getProperty, setProperty
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
isEnabled
public java.lang.Object onRequest(ActivityRuntimeContext runtimeContext, java.lang.Object request, java.util.Map<java.lang.String,java.lang.String> headers)
AdapterMonitor
onRequest
in interface AdapterMonitor
runtimeContext
- The workflow runtime context of the adapter activityrequest
- The request message content (String, XMLBean, JAXB Element, JSONObject, etc).headers
- Protocol header values. May be modified by the monitor.public java.lang.Object onInvoke(ActivityRuntimeContext runtimeContext, java.lang.Object request, java.util.Map<java.lang.String,java.lang.String> headers)
AdapterMonitor
onInvoke
in interface AdapterMonitor
runtimeContext
- The workflow runtime context of the adapter activityrequest
- Outgoing request message content (String, XMLBean, JAXB Element, JSONObject, etc).headers
- protocol headerspublic java.lang.Object onResponse(ActivityRuntimeContext runtimeContext, java.lang.Object response, java.util.Map<java.lang.String,java.lang.String> headers)
AdapterMonitor
onResponse
in interface AdapterMonitor
runtimeContext
- The workflow runtime context of the adapter activityresponse
- The response that was received from the external system. (String, XMLBean, JAXB Element, JSONObject, etc).headers
- Protocol headers for the incoming response. New headers can be injected by the monitor.public java.lang.String onError(ActivityRuntimeContext runtimeContext, java.lang.Throwable t)
AdapterMonitor
onError
in interface AdapterMonitor
runtimeContext
- adapter workflow contextCopyright © 2018 CenturyLink, Inc.


Most people will search for your website to know more about you. That is why your website is more than just a digital space;
it is your identity on the World Wide Web! Apart from playing a pivotal role in establishing your digital presence, it also acts
as a platform to showcase your strengths. To be able to hold a user's attention, websites have to be visually appealing, user-friendly
and easy to navigate.
UX/UI Design
- Everyone wants to look great on the internet! That is why user experience and user interfaces are the key ingredients of a
successful good looking website. The interface between people and technology makes or breaks the success of a digital experience.
Our web designers are equipped in solving complex business problems to create functional and user-friendly digital solutions.
Web Strategy
- The websites we develop are based on an in-depth understanding of the market in which the brand operates. Instead of treating
the website as a stand-alone entity, we make sure it is integrated well into the brand's various communication channels from print to
social media. We truly believe that a website is a gateway towards greater and deeper brand experience.
Responsive Development
- Having a responsive website enables it to adapt to the device of each unique visitor, whether desktop, smartphone or tablet.
Also, it's a widely preferred option when it comes to making the website search engine friendly. By providing a single, dynamic version
of the website to both desktop and mobile visitors, it makes it easier for search engines to understand and serve the content.
We have successfully developed numerous responsive websites using the latest technologies like HTML5.0,CSS3.0, JQuery, AJAX etc.
Portal Development
- Portal development is a multi-dimensional activity requiring proficiency at different levels. We create and develop sophisticated
portals that act as platforms to showcase a wide-array of information in an effective way. Our expertise allows building portal solutions
that combine information access and content distribution using the latest technologies like PHP, MySQL, AJAX and Python.
Search Engine Optimisation
- Compelling, engaging and frequently updated content along with accurate measures to boost page ranks is the only solution to keep
your search rankings stabilized. This ensures consistent traffic to your website or portal. Our dedicated SEO team has helped many
businesses and establishments in stabilizing their web traffic and search rankings. Keyword Analysis, On Page Optimization and Off
Page Optimization are some of the services we offer. As an SEO consultant, we remain committed to delivering quality services that place
our clients on the first page in renowned search engines like Google, Yahoo and Bing.


FEDERAL SURVEY SYSTEM
When
the American Revolution was over, the new government had no money -- but, it
had land. To pay soldiers for their
service, the government gave a soldier a land warrant as payment. A warrant is a claim, in this case to a
certain number of acres in the Western Territory. Warrants differed according to how long a man served in the
military and what his rank was. If the
soldier died in the war, then his family received the warrant for his land.
Describing
specific pieces of land was not easy.
The boundaries were unclear because no consistent method had been
established for marking tracts of land.
Areas of land are called parcels.
Most parcels were only described as a certain amount of land (a number
of acres) in a general region.
Members
of the new Congress knew that the land parcels in the western territories
needed to be described more precisely.
Congress passed the Public Land Act of 1785. They recommended that land be marked in areas shaped like
squares. The Earth's surface is round
and not flat, so parcels would not be perfectly square, but they could be close
enough.
The
land in the Northwest Territory was to be surveyed and divided into tracts of
land six miles square (6 miles x 6 miles), called townships. Then each township would be divided into 36
sections, each being 1 mile x 1 mile square.
Each township and each section was assigned a number so it could be
identified. One square mile is equal to
640 acres of land. The land that was
surveyed using this method was to have been sold for $1 an acre or $640 per
section. Within each township a section
was to be saved, not sold, in order to provide money to support new
schools. In many townships, this was
Section 16 which is located near the center of the township.
This
system of measuring and marking land for public use is known as the Federal
Survey System. It was first used in
eastern Ohio in an area just west of the Ohio River. This survey was called the Seven Ranges.
This
system of surveying land was carried into many other American lands, as the
country grew. Grids were not always
established in 6 mile x 6 mile sections, but the rectangular system was
imitated because it worked so well.
[Extracted from a publication of the Auditor of the State of Ohio titled, "Along the Ohio Trail; A Short History of Ohio Lands." Researched and written by Tanya West Dean, B.A., History, Wittenberg University and W. David Speas, B.S., Education, Heidelberg College. Edited by: Dr. George W. Knepper, Distinguished Professor of History, Emeritus, The University of Akron. Third paperback edition 2002]
Click here for the Short-Cut Table of Contents


Vijender Singh claims 12th successive win at Caesars Palace Bluewaters
Dubai: Ace boxer Vijender Singh continued with his dominant run in professional boxing as he defeated Ghana’s Charles Adamu at the Caesars Palace Bluewaters to register his 12th consecutive win.
Vijender, 34, was adjudged winner by unanimous decision in a bout that he dominated from the very beginning on Friday night.
“Happy to continue my winning streak and making it 12-0 here in Dubai. Thanks to all my friends and fans for always supporting and believing in me,” Vijender said in a tweet following his emphatic victory.
Adamu had come into the contest with an experience of 47 bouts, of which he had won 33 (26 knockouts). The 42-year-old represented Ghana at the 1998 Commonwealth Games in Kuala Lumpur and won bronze. He made his professional debut in August 2001. He fought Ukrainian Vitali Tsypko in February 2004 for the WBA Inter-Continental and suffered the first defeat of his pro career. He was the Commonwealth Super middleweight champion twice, first between August 2003 and March 2004 and then from December 2009 to April 2010.
This was Vijender’s second win of the year. His previous bout, which was also his first in the US, was in August in which he had defeated Mike Snider via a fourth-round TKO. Vijender is the WBO Asia Pacific and Oriental super middleweight champion. IANS
Also Read: Vijender Singh to face former Commonwealth Champion
Also Watch: Actress Amrita Gogoi promotes ‘Pratighat’ at Namti in Sivasagar


Mike Bushell: BBC supported me after Strictly death threat
Mike Bushell has said he has had lots of support from both the BBC and fans after receiving a death threat for remaining in Strictly Come Dancing.
The BBC Breakfast sports host was the target of online abuse following the judges’ decision to keep him and partner Katya Jones in the competition following the dance-off against Catherine Tyldesley and Johannes Radebe last weekend.
One of the messages on social media said that he would be a “dead man” unless he withdrew from the BBC One show.
BBC Breakfast, Strictly, everyone said, 'Do you want to talk about it, are you worried about it?' And I said no, thanks for the offer but all is fine, rise above it, we'll just carry on.
Bushell, 53, said the threat was “ridiculous” and that he has found solace in the number of positive messages he has since received.
“After that, I had so much support over the week, so many nice messages, so that far outweighs the nasty ones,” he said.
“BBC Breakfast, Strictly, everyone said, ‘Do you want to talk about it, are you worried about it?’
“And I said no, thanks for the offer but all is fine, rise above it, we’ll just carry on.
“But the BBC is brilliant, they’re very supportive with anything like that, they’re very experienced in dealing with that but, no, honestly we’re fine.”
Bushell said he wanted to report the person who sent the “vile, abusive” message, “but then they deleted the tweet”.
He added: “I’ve no problem at all with people having opinions about who their favourite couples are, and the plan is always to do our best, and then it’s up to the judges, up to the public and you just do your best in the dance-off and accept the decision.
“That’s what Catherine and Johannes did, and we’ve had lovely messages from them, but some people… it’s an entertainment show at the end of the day, so it’s crazy to get that.”
Bushell’s wife Emily had defended him on Twitter, saying that he “danced well and deserves his spot on the show” as she told of her shock about the “level of abuse” he received.
Bushell and Jones returned to the dancefloor on Saturday night with a Charleston to Those Magnificent Men In Their Flying Machines by the Ron Goodwin Orchestra.
Strictly Come Dancing: The Results is on BBC One at 7.15pm on Sunday.


[Erowid Note: Driving while intoxicated or tripping is dangerous and irresponsible because it endangers other people. Don't do it!]
Having done a great deal of spiritual 'inner work' over the last 5 or 6 years I had gotten to a very clear frame of consciousness. Day to day life had become very upbeat and positive. Yet being a self proclaimed control freak all my life, the spiritual concept of 'letting go' and 'surrendering' had been a very difficult concept to master. That is until I met a teacher called Tina (Crystal Meth.)
I had never taken any drug before in my life, the concept of being 'out of control' had scared me too much to permit such a thing. Yet I kept being led to situations where people were 'partying' with Crystal. Seeing I was being guided, I decided to maybe allow myself to experience this drug.
I met someone for sex. He had smoked some crystal and was having a great time, but I still was hesitant. We took a break and he lit up again. The urge overtook me and I gave in, I asked him to show me how. He lit it and explained how to inhale. I expected my body to protest like it does to cigarette smoke, but it didn't. I took a lung full, held it, then exhaled. WHOA!! I could feel my body getting lighter and relaxing. I took 4 more hits before I was so buzzing it was clear to both of us I had enough for now.
Any worries, emotional hang-ups or self doubts I had simply melted away. I felt clearer then clear. I was extremely present and feeling all my senses with a profundity that was unmatched by any experience I had ever had before in my life. Even my connection to spirit was sharper, no distortion.
The sex was out of this world. My senses were so heightened that I could feel everything that occurred, every sensation not only from my body, but from his body as well! Every thrust felt like pure heaven dripping in liquid gold! Spirit explained, 'This is what it is like to live in a body in your highest state of awareness. This is the true You, your essence.' I just basked in that awareness and sensation as waves of pleasure and love flooded over my entire body. Spirit added, '...and you won't need drugs to experience this.'
I had received my invitation. To reach a state of consciousness that is so clear, that this depth of sensation and emotion become my natural state of being.
We stopped again a while later, my body shuddering with pleasure. He offered me the pipe again and I took 4 more hits (for a total of 9). We continued to be sexual for a while longer until he came and it was clear he was ready for me to leave. I was more than satisfied.
I was concerned about driving but he (and spirit) assured me it was not a problem. The short drive home was amazing. I could see and notice things that I would not normally notice in my sober alert state. My depth of clarity and sharpness of sight was incredible.
Once home, I stepped into the shower for what would be the start of the real reason for this drug. To bring up old emotional issues and fears for effortless removal. What most people describe as the 'crash' is what I found to be a 'working' space. As issues presented themselves, I had the clarity to see that these things did not belong in my body/consciousness and could simply allow them to be effortlessly released from my body.
I now had a new benchmark. To feel this clear and free ALL THE TIME!
A fear would surface gently. Instead of pushing the fear away I felt confident enough to call the fear forward and literally ask the fear how it had served me (to have it in my life.) I could feel the fear then 'expose' why it had been drawn into my life. I could see how the fear had protected me from something as I was growing up and could clearly see how it was no longer necessary. I would thank the fear for it's service and allow it leave. In it's place I was left with the love that is actually hidden behind all fears. As I released more fears, I felt more love. Within hours I was so overwhelmed with love that I had to stop releasing fears. As I stopped doing it consciously and went to lay down, the process continued on it's own. It kept going and going. Fears melted away and more love flooded in. After 6 hours, I had dropped hundreds of life-long fears and was completely overwhelmed by love.
In a pinnacle moment I struggled with a fear of having 'too much love'. My heart and body felt like it were going to explode and the pressure seemed to keep building. I heard the words, 'surrender to love, surrender to love...' keep repeating. Because I could do nothing else, I let go. I surrendered completely.
The world around me disappeared and I saw at once, the world as God sees it. I could now see any aspect of life, past-present-future, from a spiritual perspective. I traveled back to parts of my life where some of my most intense struggles had been and saw the beauty of how those situations had molded me into a more kind and loving person. I saw that the struggles I experienced were not put there by God, they were of my own creation. I saw the infinite things that took place to assist me overcoming all the odds that I had drawn into my life. I saw how even the leaves on the trees cheered for me as I walked by them.
I could see how all things in the universe really were there for my good. I could feel how everything and everyone I interacted with were really all wanting my best and highest good. I could see quite clearly that the drama I felt I had been stuck in were all really an illusion to help me to experience things that I had chosen to experience. I could see that behind all things in the universe, was really the essence of pure unconditional love. The essence of God.
I stayed in this space for many hours, though it felt timeless. Anything I could think of, I was instantly shown from a spiritual perspective. Mysteries that I had had my entire life, were instantly revealed.  More and more of my life and the entire universe came into clarity. Seemingly unanswerable questions all of a sudden made perfect sense. The big picture was unfolding with immense clarity.
For the next two days I wobbled in and out of the most intense connection with God and knowingness that one could imagine, and spaces of deep reflection. I experienced a surrendering my body to the feeling of death. I experienced a profound space of seeing how even the seemingly darkest most evil things on the planet, were really all part of God's plan for unfoldment of an ultimate state of enlightenment on this planet.
I could see that all 'evil' was really only a misperception that we carry. That 'evil' is nothing more than a allusion that actually has it's ultimate roots in God and love. That some of the most 'evil' things on the planet will some day unfold to be the brightest sources of love that one can imagine.
With each new insight I could feel old hang-ups in me simply melt away. Just by seeing and understanding the true nature of a loving universe, I could not help but let go of anger, resentment, fears, sadness, and failure. Because I could see and feel that there was really no support for any of the issues I felt I had.
At the end of my third day I was utterly and completely exhausted but more full of love and joy then I had ever felt in my life. While I had done almost nothing but lay or sit around for 3 days, my body and mind felt completely trashed. I got the message that it was time to get grounded again. So I began eating and following my body's guidance to getting back in balance again.
The entire world looked completely new. I could not help but see and feel things from my new vantage point of awareness. I spent days 4-6 simply laying around marveling at the wonders of the world while slowly reintegrating myself into it. While I had only took those initial 9 hits, the entire process took my body about 10 days to regain a sense of 'normality.' The bulk of this was due to the intensity of the work I had done on letting go of my past.
In the weeks that followed I was continually dumbfounded by how much different I was. While the world looked the same as it had visually, it now felt completely different. Things that I used to react to, I now didn't. Things that used to annoy me and get me upset, simply made me smile. While my moods would occasionally wane, the intense growth and insight that I had stayed consistent. Where I used to struggle to gain intuitive information, it now simply 'fell out of me.' I would find myself interacting with my clients and telling them all kinds of things I just some how 'knew' about their body and how they could get themselves back into balance.
My intuitive abilities had opened up 100 fold. For the first time in my life, I lived in a space of gratitude and joy as my predominant emotions. My ability to surrender to the feelings of love and connectedness in intimate situations was bordering on overwhelming. Tears of love became a common experience in my life. Just taking a walk in the neighborhood and connecting with the trees and nature could take me into a space of natural bliss. After being completely sober for over 40 days and this still being my natural reality, I knew this was permanent. All those experiences that I could have written off as mental hallucinations, I could not ignore.
I also knew that I had not attained my ultimate space yet. There was still more to let go of. I had still more of my past to surrender and that Tina (Crystal Meth), my teacher, was not yet done teaching me about surrender.
Since this first experience I have had 6 others over a 4 month span of time. While each one is less profound then the previous, the space which is my 'normal' sober reality continues to get better and better. States of clarity that I had never thought possible are now my natural reality. Very little about the world now troubles or disturbs me. While I have surrendered a great deal of my attachment to the world, I am more connected then ever before, not only to spirit, but to everyone whom I contact. Instead of struggling with the world, I have learned to surrender to the harmony that is always present. Tina taught me that.
I have now begun using this teacher, Tina, to assist other 'control addicts' in learning to surrender to the flow of the universe. I have realized that Tina will teach me to surrender, that's her job. If you do it consciously, the rewards are amazing. As an Ethnogenic Explorer and Shaman I find Tina to be an indispensable healing tool.
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.


pg_disconnect conn
conn
pg_disconnect closes a connection to the PostgreSQL server.
pg_disconnect
The handle of the connection to be closed.
None


{# File For Strings That Need L10N But Do Not Appear On The Website #}
{# L10n: Copy For Slide Based (PDF), each line correspondes to a specific slide. If text is shorter, please make sure we have text per slide. #}
{% trans %}
Get Mobilized
Getting mobilized means getting more connected to one another - so we can all go further.
Because the world's gone mobile.
And it's time to bring the values that Firefox has always championed in the browser...
...to the devices that the next billion people will use as their primary gateway to the Web.
With Firefox OS, we're making smartphones more accessible...
...while empowering more users in more ways.
It's not (just) about technology.
Or a browser on a mobile device.
It's about enabling more people to take advantage of the full power of the Web...
...giving more individuals more access to content they didn't know was available...
...content that can change their lives and allow them to create and participate in the Web.
It's about discovering and enjoying the content that matters most to them and their future.
That's where you come in.
Your video should demonstrate what having the Web in your hands can do for you...
...and how it affects those around you.
What possibilities open up when there are no barriers to entry, to participation or to creation?
Help us inspire people to Get Mobilized for individual and collective progress.
Here are a few tips to get you started:
Your video should be 60 seconds or less.
Please don't show any branded devices.
Don't focus on Firefox, but rather the power and potential of mobile.
It can be animated or live action. (Or both - get creative!)
It can be funny, quirky or serious. It's up to you!
But make it inspiring, dynamic, hopeful and optimistic.
Your video should talk to ordinary people, not geeks, hackers or expert coders.
(Try thinking of people who aren't online yet.)
We've prepared a few things to help. Feel free to use them if you like.
You can download them here: {URL TBD}
Together, we can bring the promise of the Web to more people in more places.
Get ready.
Get creating.
Get Mobilized.
{% endtrans %}
{# L10n: Copy For Homepage Promo That Will Link To the 2013 Gallery Of Entries #}
{{ _('Meet your competition') }}
{# L10n: Copy For Homepage Promo That Will Link To the 2013 Gallery Of Entries #}
{{ _('View the gallery of entries') }}


OpenVidu Angular Documentation
Modules
ApiDirectiveModule
dependencies
dependencies
cluster_ApiDirectiveModule
cluster_ApiDirectiveModule_exports
cluster_ApiDirectiveModule_declarations
ActivitiesPanelRecordingActivityDirective
ActivitiesPanelRecordingActivityDirective
ApiDirectiveModule
ApiDirectiveModule
ActivitiesPanelRecordingActivityDirective->ApiDirectiveModule
AdminLoginDirective
AdminLoginDirective
AdminLoginDirective->ApiDirectiveModule
AdminRecordingsListDirective
AdminRecordingsListDirective
AdminRecordingsListDirective->ApiDirectiveModule
AudioMutedDirective
AudioMutedDirective
AudioMutedDirective->ApiDirectiveModule
CaptionsLangDirective
CaptionsLangDirective
CaptionsLangDirective->ApiDirectiveModule
LangDirective
LangDirective
LangDirective->ApiDirectiveModule
MinimalDirective
MinimalDirective
MinimalDirective->ApiDirectiveModule
ParticipantNameDirective
ParticipantNameDirective
ParticipantNameDirective->ApiDirectiveModule
ParticipantPanelItemMuteButtonDirective
ParticipantPanelItemMuteButtonDirective
ParticipantPanelItemMuteButtonDirective->ApiDirectiveModule
PrejoinDirective
PrejoinDirective
PrejoinDirective->ApiDirectiveModule
RecordingActivityRecordingErrorDirective
RecordingActivityRecordingErrorDirective
RecordingActivityRecordingErrorDirective->ApiDirectiveModule
RecordingActivityRecordingsListDirective
RecordingActivityRecordingsListDirective
RecordingActivityRecordingsListDirective->ApiDirectiveModule
StreamDisplayAudioDetectionDirective
StreamDisplayAudioDetectionDirective
StreamDisplayAudioDetectionDirective->ApiDirectiveModule
StreamDisplayParticipantNameDirective
StreamDisplayParticipantNameDirective
StreamDisplayParticipantNameDirective->ApiDirectiveModule
StreamSettingsButtonDirective
StreamSettingsButtonDirective
StreamSettingsButtonDirective->ApiDirectiveModule
ToolbarBackgroundEffectsButtonDirective
ToolbarBackgroundEffectsButtonDirective
ToolbarBackgroundEffectsButtonDirective->ApiDirectiveModule
ToolbarCaptionsButtonDirective
ToolbarCaptionsButtonDirective
ToolbarCaptionsButtonDirective->ApiDirectiveModule
ToolbarChatPanelButtonDirective
ToolbarChatPanelButtonDirective
ToolbarChatPanelButtonDirective->ApiDirectiveModule
ToolbarDisplayLogoDirective
ToolbarDisplayLogoDirective
ToolbarDisplayLogoDirective->ApiDirectiveModule
ToolbarDisplaySessionNameDirective
ToolbarDisplaySessionNameDirective
ToolbarDisplaySessionNameDirective->ApiDirectiveModule
ToolbarFullscreenButtonDirective
ToolbarFullscreenButtonDirective
ToolbarFullscreenButtonDirective->ApiDirectiveModule
ToolbarLeaveButtonDirective
ToolbarLeaveButtonDirective
ToolbarLeaveButtonDirective->ApiDirectiveModule
ToolbarParticipantsPanelButtonDirective
ToolbarParticipantsPanelButtonDirective
ToolbarParticipantsPanelButtonDirective->ApiDirectiveModule
ToolbarScreenshareButtonDirective
ToolbarScreenshareButtonDirective
ToolbarScreenshareButtonDirective->ApiDirectiveModule
ToolbarSettingsButtonDirective
ToolbarSettingsButtonDirective
ToolbarSettingsButtonDirective->ApiDirectiveModule
VideoMutedDirective
VideoMutedDirective
VideoMutedDirective->ApiDirectiveModule
ActivitiesPanelRecordingActivityDirective
ActivitiesPanelRecordingActivityDirective
ApiDirectiveModule->ActivitiesPanelRecordingActivityDirective
AdminLoginDirective
AdminLoginDirective
ApiDirectiveModule->AdminLoginDirective
AdminRecordingsListDirective
AdminRecordingsListDirective
ApiDirectiveModule->AdminRecordingsListDirective
AudioMutedDirective
AudioMutedDirective
ApiDirectiveModule->AudioMutedDirective
CaptionsLangDirective
CaptionsLangDirective
ApiDirectiveModule->CaptionsLangDirective
LangDirective
LangDirective
ApiDirectiveModule->LangDirective
MinimalDirective
MinimalDirective
ApiDirectiveModule->MinimalDirective
ParticipantNameDirective
ParticipantNameDirective
ApiDirectiveModule->ParticipantNameDirective
ParticipantPanelItemMuteButtonDirective
ParticipantPanelItemMuteButtonDirective
ApiDirectiveModule->ParticipantPanelItemMuteButtonDirective
PrejoinDirective
PrejoinDirective
ApiDirectiveModule->PrejoinDirective
RecordingActivityRecordingErrorDirective
RecordingActivityRecordingErrorDirective
ApiDirectiveModule->RecordingActivityRecordingErrorDirective
RecordingActivityRecordingsListDirective
RecordingActivityRecordingsListDirective
ApiDirectiveModule->RecordingActivityRecordingsListDirective
StreamDisplayAudioDetectionDirective
StreamDisplayAudioDetectionDirective
ApiDirectiveModule->StreamDisplayAudioDetectionDirective
StreamDisplayParticipantNameDirective
StreamDisplayParticipantNameDirective
ApiDirectiveModule->StreamDisplayParticipantNameDirective
StreamSettingsButtonDirective
StreamSettingsButtonDirective
ApiDirectiveModule->StreamSettingsButtonDirective
ToolbarBackgroundEffectsButtonDirective
ToolbarBackgroundEffectsButtonDirective
ApiDirectiveModule->ToolbarBackgroundEffectsButtonDirective
ToolbarCaptionsButtonDirective
ToolbarCaptionsButtonDirective
ApiDirectiveModule->ToolbarCaptionsButtonDirective
ToolbarChatPanelButtonDirective
ToolbarChatPanelButtonDirective
ApiDirectiveModule->ToolbarChatPanelButtonDirective
ToolbarDisplayLogoDirective
ToolbarDisplayLogoDirective
ApiDirectiveModule->ToolbarDisplayLogoDirective
ToolbarDisplaySessionNameDirective
ToolbarDisplaySessionNameDirective
ApiDirectiveModule->ToolbarDisplaySessionNameDirective
ToolbarFullscreenButtonDirective
ToolbarFullscreenButtonDirective
ApiDirectiveModule->ToolbarFullscreenButtonDirective
ToolbarLeaveButtonDirective
ToolbarLeaveButtonDirective
ApiDirectiveModule->ToolbarLeaveButtonDirective
ToolbarParticipantsPanelButtonDirective
ToolbarParticipantsPanelButtonDirective
ApiDirectiveModule->ToolbarParticipantsPanelButtonDirective
ToolbarScreenshareButtonDirective
ToolbarScreenshareButtonDirective
ApiDirectiveModule->ToolbarScreenshareButtonDirective
ToolbarSettingsButtonDirective
ToolbarSettingsButtonDirective
ApiDirectiveModule->ToolbarSettingsButtonDirective
VideoMutedDirective
VideoMutedDirective
ApiDirectiveModule->VideoMutedDirective
Zoom in
Reset
Zoom out
Info
File
src/lib/directives/api/api.directive.module.ts
Declarations
ActivitiesPanelRecordingActivityDirective
AdminLoginDirective
AdminRecordingsListDirective
AudioMutedDirective
CaptionsLangDirective
LangDirective
MinimalDirective
ParticipantNameDirective
ParticipantPanelItemMuteButtonDirective
PrejoinDirective
RecordingActivityRecordingErrorDirective
RecordingActivityRecordingsListDirective
StreamDisplayAudioDetectionDirective
StreamDisplayParticipantNameDirective
StreamSettingsButtonDirective
ToolbarBackgroundEffectsButtonDirective
ToolbarCaptionsButtonDirective
ToolbarChatPanelButtonDirective
ToolbarDisplayLogoDirective
ToolbarDisplaySessionNameDirective
ToolbarFullscreenButtonDirective
ToolbarLeaveButtonDirective
ToolbarParticipantsPanelButtonDirective
ToolbarScreenshareButtonDirective
ToolbarSettingsButtonDirective
VideoMutedDirective
Exports
ActivitiesPanelRecordingActivityDirective
AdminLoginDirective
AdminRecordingsListDirective
AudioMutedDirective
CaptionsLangDirective
LangDirective
MinimalDirective
ParticipantNameDirective
ParticipantPanelItemMuteButtonDirective
PrejoinDirective
RecordingActivityRecordingErrorDirective
RecordingActivityRecordingsListDirective
StreamDisplayAudioDetectionDirective
StreamDisplayParticipantNameDirective
StreamSettingsButtonDirective
ToolbarBackgroundEffectsButtonDirective
ToolbarCaptionsButtonDirective
ToolbarChatPanelButtonDirective
ToolbarDisplayLogoDirective
ToolbarDisplaySessionNameDirective
ToolbarFullscreenButtonDirective
ToolbarLeaveButtonDirective
ToolbarParticipantsPanelButtonDirective
ToolbarScreenshareButtonDirective
ToolbarSettingsButtonDirective
VideoMutedDirective
results matching "
"
No results matching "
"


Why Virtual Data?
If it is not real data, then what is the value of it? Virtual data is something that, when you need it, has no substitute.
To explain why, let us consider the trade-offs in some basic simulation and testing challenges and what they mean.
Challenge: access large amounts of bulk data
Actual Data
- depends primarily on speed and efficiency of storage system
- limited to size of storage system
Virtual Data
- depends on speed of generation functions and CPU
- not effectively limited to size of storage
In this case, virtual data is strongly favored for testing systems that need to be faster than the things that they are targeting. This is an essential requirement for any system that must provide high-fidelity results in timing, loading levels, etc. Essentially, load testing is a primary reason for having procedurally generated data. You can not easily get high fidelity results if the testing apparatus is saturated with load as easily as the test target.
Challenge: modify basic properties of test data
Actual Data
- requires recapture of test data, regardless of origin
Virtual Data
- has no moving mass, instantly changes according to recipe
The ability to change your data set instantly is also a boon for testing systems. Not only can you modify the conditions of a test by changing out your virtual data set, you can create multiple variations that can elicit interesting contrasts and outcomes, ad-infinitum. The size of a virtual data set is paltry, often smaller than testing logic.
Challenge: create nuanced interplay between data
Actual Data
- same design burden as virtual data, but still with moving mass
- significant effort is spent on managing bulk of data
Virtual Data
- is able to create statistically shaped data without bulk transfer
- is able to provide determinism in addition to statistical shaping
- is able to simulate superset/subset relationships
Because virtual data is dependent on the generation methods, and generation methods can be chosen themselves to have interesting mathematical relationships, many things are possible that we don't even consider when raw data is handed to us.
Challenge: access real data
Real data wins this one, obviously. Virtual data is not strictly real data, but it can be. Read further for why.
Challenge: access realistic data
Virtual data can be as realistic as you need it to be, up to and including being based on samples of real data. If you want to capture a real data set and access it as such through a virtual interface, then the data is, in fact, real data.
 With a small amount of real data, you can create a very high volume of simulated data. The small sample is almost always easy to fit in memory, keeping the data generators fast. Still, the data generated can be extrapolated to data set sizes that can be useful for testing even the largest systems.
For accessing realistic data, why not both? If you have an example data set, nothing prevents you from using it as raw data through the virtual data interface. Doing so gives you useful choices for tackling some of the challenges above.
Challenge: partition a dataset for distributed testing
Real Data
- Requires a bulk processing step to do any reconfiguration or (re)partitioning
Virtual Data
- Subset groupings of virtual data are easily described by common recipes.
When you need to be able to identify or control, or vary how data is distributed in a testing scenario, there is no comparison.
Challenge: canonically identify detailed test data parameters
Real Data
- In order to canonically capture and represent the testing parameters with a real bulk dataset, you have to have and retain the whole dataset.
Virtual Data
- Virtual data can be described concisely and completely in a recipe. Whether you are needing book end scenarios that identify corner cases, or more normal data, the recipes are compact. For data that is based on real samples, you get to pick how much is too much.
In Summary
It is possible to have realistic samples, statistical shaping, high throughput, immediately adaptivity, and repeatability at the same time.
The examples above are only the tip of the iceberg in terms of what is possible. Virtual DataSet aims to make it easier to explore and use new dataset simulation methods.


My Favorite Things
These are a few of my favorite things:
Actors
Here are some of my favorite actors:
- Daniel Day Lewis
- Gary Oldman
- Sarah Silverman
Movies
Here are some of my favorite movies:
- Die Hard
- The Princess Bride
- Most of the Harry Potter Movies
Thanks for reading about me!


When the website is ready, you'll be able to choose one of the following:
{% for option in options %} {{ option }}
{% endfor %}


For the best viewing experience, we recommend downloading a modern browser or enabling JavaScript in your current browser and refresh the page.


My name is Arka Sinha. I am originally from West Bengal. My father had a job where he would get frequent transfers so we never really stayed at a place. My mom is a housewife. I am currently staying in Chandigarh.
Some of my hobbies are-
Below is how I prioritize the things in my life:
| COURSE | PLATFORM |
| Basics of C language | Coursera |
| Basics of Python language | Coursera |
| Python Data Structures | Coursera |


{% load rest_framework %}
Current User : {{request.user.username}}
Rating List
User must be logged in!


[ The effect of 24, 25-dihydroxyvitamin D3 (dioxyvit) on Ca metabolism and immune status during chronic kidney failure] Active metabolite of vitamin D3, 24R, 25 (OH) 2D3 (dioxyvit) was used at a daily dose of 100 micrograms in treatment of children affected with tubulointerstitial disease of kidney and with chronic glomerulonephritis under conditions of kidney insufficiency.
Abstract
The drug exhibited distinct normalizing effect on patterns of calcium metabolism: increase of total and ionized Ca2+ and of 25-OHD, decrease in concentration of parath hormone and osteocalcine in blood serum as well as on immunological parameters: restoration of decreased content of T- and 0-lymphocytes. Concentration of receptors of hormonal form of 1, 25 (OH) 2D3 was found to be minimal in lymphocytes under conditions of chronic kidney insufficiency, while their expression, after the dioxyvit action, was detected only in patients with glomerulonephritis. Specific calcitropic effect of dioxyvit with simultaneous correction of vitamin D deficiency were apparently responsible for high efficacy of the drug in treatment of calcium metabolism and immunity impairments in children with renal deteriorations at the step of chronic kidney insufficiency.


timedatectl - Control the system time and date
timedatectl [OPTIONS...] {COMMAND}
timedatectl may be used to query and change the system clock and its settings.
The following options are understood:
--no-ask-password
Do not query the user for authentication for privileged operations.
--adjust-system-clock
If set-local-rtc is invoked and this option is passed, the system clock is synchronized from the RTC again, taking the new setting into account. Otherwise, the RTC is synchronized from the system clock.
-H, --host=
Execute the operation remotely. Specify a hostname, or a username and hostname separated by "@", to connect to. The hostname may optionally be suffixed by a container name, separated by ":", which connects directly to a specific container on the specified host. This will use SSH to talk to the remote machine manager instance. Container names may be enumerated with machinectl -H HOST.
-M, --machine=
Execute operation on a local container. Specify a container name to connect to.
-h, --help
Print a short help text and exit.
--version
Print a short version string and exit.
--no-pager
Do not pipe output into a pager.
The following commands are understood:
status
Show current settings of the system clock and RTC.
set-time [TIME]
Set the system clock to the specified time. This will also update the RTC time accordingly. The time may be specified in the format "2012-10-30 18:17:16".
set-timezone [TIMEZONE]
Set the system time zone to the specified value. Available timezones can be listed with list-timezones. If the RTC is configured to be in the local time, this will also update the RTC time. This call will alter the /etc/localtime symlink. See localtime(5) for more information.
list-timezones
List available time zones, one per line. Entries from the list can be set as the system timezone with set-timezone.
set-local-rtc [BOOL]
Takes a boolean argument. If "0", the system is configured to maintain the RTC in universal time. If "1", it will maintain the RTC in local time instead. Note that maintaining the RTC in the local timezone is not fully supported and will create various problems with time zone changes and daylight saving adjustments. If at all possible, keep the RTC in UTC mode. Note that invoking this will also synchronize the RTC from the system clock, unless --adjust-system-clock is passed (see above). This command will change the 3rd line of /etc/adjtime, as documented in hwclock(8).
set-ntp [BOOL]
Takes a boolean argument. Controls whether NTP based network time synchronization is enabled (if available).
On success, 0 is returned, a non-zero failure code otherwise.
$SYSTEMD_PAGER
Pager to use when --no-pager is not given; overrides $PAGER. Setting this to an empty string or the value "cat" is equivalent to passing --no-pager.
$SYSTEMD_LESS
Override the default options passed to less ("FRSXMK").
Show current settings:
$ timedatectl Local time: Fri, 2012-11-02 09:26:46 CET Universal time: Fri, 2012-11-02 08:26:46 UTC RTC time: Fri, 2012-11-02 08:26:45 Timezone: Europe/Warsaw UTC offset: +0100 NTP enabled: no NTP synchronized: no RTC in local TZ: no DST active: no Last DST change: CEST → CET, DST became inactive Sun, 2012-10-28 02:59:59 CEST Sun, 2012-10-28 02:00:00 CET Next DST change: CET → CEST, DST will become active the clock will jump one hour forward Sun, 2013-03-31 01:59:59 CET Sun, 2013-03-31 03:00:00 CEST
Enable an NTP daemon (chronyd):
$ timedatectl set-ntp true ==== AUTHENTICATING FOR org.freedesktop.timedate1.set-ntp === Authentication is required to control whether network time synchronization shall be enabled. Authenticating as: user Password: ******** ==== AUTHENTICATION COMPLETE ===
$ systemctl status chronyd.service chronyd.service - NTP client/server Loaded: loaded (/lib/systemd/system/chronyd.service; enabled) Active: active (running) since Fri, 2012-11-02 09:36:25 CET; 5s ago ...
systemd(1), hwclock(8), date(1), localtime(5), systemctl(1), systemd-timedated.service(8)


University of Colorado, Boulder
- BA, Economics
- Minor in TAM – Technology Arts and Media
- Minor in Atmospheric and Oceanic Sciences
EXPERIENCE
June 2016-Dec.2016
Vail Resorts
Broomfield, CO
HRIS Season Support
- HRIS Intern at Vail Corporate office.
- Worked with HRIS department on project throughout summer and into school year.
- Conducted HR back filing and Indexing involving all Vail locations through OnBase.
Nov. 2014-Dec. 2015
Theta Xi Fraternity, Alpha Eta Chapter
Boulder, CO
Membership Chair
- Served on Executive Board.
- Coordinated entire recruitment process during spring and fall terms, including planning Open Houses and Preference Night for 300+ men – a formal event including dinner, speeches, and interviews for potential new members.
- Planned associate period for new members.
Summer 2015
College Student Storage
Boulder, CO
Mover
- Worked in teams to move students in and out of apartments and houses.
- Organized storage warehouses and loaded moving trucks.
Jan. 2014-Dec.2015
Theta Xi Fraternity, Alpha Eta Chapter
Boulder, CO
Director of Social
- Planned and Organized social events for 140-member fraternity.
- Scheduled security for registered events, worked with risk management chairman.
Summer 2014 & 2015
City of San Ramon, Parks and Community Services
CA
Assistant Pool Manager
- Managed Daily Operations and Swim Lesson Programs.
- Interacted with patrons and parents concerning questions about protocol and programming.
Dec. 2012 - July2013
Vail Resorts, Any Mountain Outdoor Store
Dublin, CA
Sales Associate
- Sold ski equipment and other outdoor products.
- Provided customized advise for client needs
- Conducted store Inventory and shipping
Dec. 2012-July 2013
City of San Ramon, Parks and Community Services
CA
Lifeguard II
- Performed lifeguard duties and taught swim lessons at two city facilities.
- Promoted from Lifeguard I to Lifeguard II during summer of 2011.
Summer 2009
Boy Scouts of America, M.D.S.C., Camp Wolfeboro
Arnold, CA
Mountaineer
- Provided merit Badge counseling and lifeguard duties to Boy Scouts
Skills
Computer:Proficient on Both Mac OS and Windows, MS Office, Adobe Creative Suite, Social Media apps
Interests
Outdoor Recreation: Skiing, Backcountry Skiing, Backpacking, Hiking, Surfing, Swimming, Water Polo
Technology/Media Arts: Photography, Videography, Motion Graphics, Music Creation, Video Games
Honors and Recognition
Summer 2014
City of San Ramon Aquatics Employee of the Year
Fall 2012
Eagle Scout, Boy Scouts of America
References available upon request.
HTML version | E-mailable HTML version | Plain Text (.txt) version.
Valid XHTML 1.1 / CSS 2.0


Start searching
Toggle Advanced Options
I'm looking to buy
Description
Condition:
Any
Brand new
Already used
Newly replaced
Defective
Warranty:
Any
Personal warranty
Shop warranty
No warranty
Price min
Price max
Sort by:
Post date
Price
Name
Item owner
Sort by:
Descending
Ascending
Search


Data Structures | |
| struct | PIMA_Container_t |
| PIMA Still Image Device Command/Response Container. More... | |
Defines | |
| #define | UNICODE_STRING_LENGTH(Chars) ((Chars) << 1) |
| #define | PIMA_COMMAND_SIZE(Params) ((sizeof(PIMA_Container_t) - 12) + ((Params) * sizeof(uint32_t))) |
| #define | PIMA_DATA_SIZE(DataLen) ((sizeof(PIMA_Container_t) - 12) + (DataLen)) |
Enumerations | |
| enum | PIMA_Container_Types_t { PIMA_CONTAINER_Undefined = 0, PIMA_CONTAINER_CommandBlock = 1, PIMA_CONTAINER_DataBlock = 2, PIMA_CONTAINER_ResponseBlock = 3, PIMA_CONTAINER_EventBlock = 4 } |
| enum | SI_Descriptor_ClassSubclassProtocol_t { SI_CSCP_StillImageClass = 0x06, SI_CSCP_StillImageSubclass = 0x01, SI_CSCP_BulkOnlyProtocol = 0x01 } |
| enum | PIMA_ResponseCodes_t { PIMA_RESPONSE_OK = 1, PIMA_RESPONSE_GeneralError = 2, PIMA_RESPONSE_SessionNotOpen = 3, PIMA_RESPONSE_InvalidTransaction = 4, PIMA_RESPONSE_OperationNotSupported = 5, PIMA_RESPONSE_ParameterNotSupported = 6 } |
Constants, Types and Enum definitions that are common to both Device and Host modes for the USB Still Image Class.
| #define PIMA_COMMAND_SIZE | ( | Params ) | ((sizeof(PIMA_Container_t) - 12) + ((Params) * sizeof(uint32_t))) |
Used in the DataLength field of a PIMA container, to give the total container size in bytes for a command container.
| [in] | Params | Number of parameters which are to be sent in the Param field of the container. |
| #define PIMA_DATA_SIZE | ( | DataLen ) | ((sizeof(PIMA_Container_t) - 12) + (DataLen)) |
Used in the DataLength field of a PIMA container, to give the total container size in bytes for a data container.
| [in] | DataLen | Length in bytes of the data in the container. |
| #define UNICODE_STRING_LENGTH | ( | Chars ) | ((Chars) << 1) |
Length in bytes of a given Unicode string's character length.
| [in] | Chars | Total number of Unicode characters in the string. |
Enum for the possible PIMA contains types.
| enum PIMA_ResponseCodes_t |
Enums for the possible status codes of a returned Response Block from an attached PIMA compliant Still Image device.
Enum for possible Class, Subclass and Protocol values of device and interface descriptors relating to the Still Image device class.


Background
In this section we introduce basic concepts, definitions and notations.
Boolean functions
Boolean regulatory functions (BRFs) are Boolean functions used in the context of biological networks and modeling. A mathematical presentation of such a function associates the activity output of a target biological entity with the Boolean input values of \(n\) variables (the regulators), such that \(f_{BRF}:\{0,1\}^n \rightarrow \{0,1\}\). Thus, the target’s output state is binary, i.e. either \(0\) (FALSE, denoting an inactive/inhibited state) or \(1\) (TRUE, indicating an active state).
The most intuitive representation of a Boolean function is its truth table, which is a list of all possible Boolean input configurations of the \(n\) regulators along with their associated function output. Since for every regulator, there are two possible values (\(0\) and \(1\)), the total number of input configurations (i.e. rows) in a truth table is \(2^n\). For example, a Boolean function \(f(x_1,x_2,x_3)\) with \(3\) regulators has a total of \(2^3=8\) rows in its corresponding truth table, starting from the input configuration \((0,0,0)\) and ending with \((1,1,1)\) (see Table 1).
The total number of BRFs with \(n\) regulators is \(2^{2^n}\) and the easiest way to think about it is to see that for each input configuration (i.e. row of the truth table) there can be only two possible function outcomes (\(0\) or \(1\)). In our example with \(3\) regulators and a total of \(8\) rows in the truth table, that would be a total of \(2^8=256\) functions, three of which are shown in Table 1 below.
| \(x_1\) | \(x_2\) | \(x_3\) | \(f_1=(x_1 \land \lnot x_3) \lor (x_2 \land \lnot x_3)\) | \(f_2=x_1 \lor (\lnot x_2 \land \lnot x_3)\) | \(f_3 = 1\) |
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 1 | 1 |
| 0 | 0 | 1 | 0 | 0 | 1 |
| 0 | 1 | 0 | 1 | 0 | 1 |
| 0 | 1 | 1 | 0 | 0 | 1 |
| 1 | 0 | 0 | 1 | 1 | 1 |
| 1 | 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 0 | 1 | 1 | 1 |
| 1 | 1 | 1 | 0 | 1 | 1 |
Truth Density
Note that the truth density of a Boolean function rests in the \([0,1]\) interval.
Using the example with the three functions from Table 1, we have \(TD_{f_1}=3/8=0.375\), \(TD_{f_2}=5/8=0.625\) and \(TD_{f_3}=8/8=1\), where the last function is the tautology, with the maximum possible truth density.
We will say that a Boolean regulatory function is biased, when it’s truth density is close to \(0\) or 1. Since the size of a truth table grows exponentially with the number of inputs a Boolean function has (\(n\) input regulators correspond to \(2^n\) rows), the existence of bias conveys the information that most of the input regulatory configurations result in either an activated or an inhibited target (bias towards \(0\) or \(1\) respectively). On the other hand, we shall say that a Boolean function is balanced, if it takes on the values \(0\) and \(1\) equally often, or equivalently, it’s truth density is close to \(\frac12\) (Benjamini, Schramm, and Wilson 2005).
The DNF form
The most practically used form of a Boolean function is its analytical form, where variables are connected with logical operators such as AND (\(\land\)), OR (\(\lor\)), NOT (\(\lnot\)), XOR (\(\oplus\)), etc. and the output of the function is calculated using basic Boolean algebra. In Table 1 for example, we provide the analytical forms for the functions \(f_1\) and \(f_2\). Note that there can be multiple analytical forms that essentially compute the same function, e.g. another form of the \(f_1\) function is \(f_1^{'}=(\lnot x_1 \land x_2 \land \lnot x_3) \lor (x_1 \land \lnot x_2 \land \lnot x_3) \lor (x_1 \land x_2 \land \lnot x_3)\).
This brings us to the notion of a general form which could be used to define useful metrics common to all Boolean functions (e.g. complexity), as well as the need to provide minimal forms. This need does not come only from a representation point of view (a more compact function form enhances readability, e.g. compare \(f_1\) with \(f_1^{'}\)), but is also a motivation for the design of optimal digital circuits, since the number of gates used (i.e. logical operators) is an indicator of computation time and affects the efficiency of a circuit (Wegener 1987).
Every Boolean function can be represented in a disjunctive normal form or DNF, requiring only AND (\(\land\)), OR (\(\lor\)) and NOT (\(\lnot\)) operators as building blocks. In such a representation, literals, which are variables (e.g. positive literal \(x\)) or their negations (e.g. negative literal \(\text{NOT }x\)), are connected by AND’s producing terms, which are then in turn connected by OR’s (Crama and Hammer 2011). For example, every function in Table 1 is expressed in DNF form, while the Boolean expressions \(\lnot (x_1 \lor x_2)\) and \(\lnot (x_1\land x_2)\lor x_3\) are not. Note that a Boolean function can have multiple DNF forms.
Complexity
The length of a DNF is defined as the number of its terms, i.e. the number of conjunctions separated by \(\lor\) operators. As such, \(l_{f_1}=l_{f_2}=2\), \(l_{f_3}=1\) and \(l_{f_1^{'}}=3\) from Table 1. Intuitively speaking, the more terms a DNF has, the more complex it is. This observation leads us to the following definition:
For example, using the functions from Table 1, for which the minimum DNF expression is given, we have that \(C_{f_1}=C_{f_2}=2/8\), \(C_{f_3}=1/8\), where the tautology \(f_3\) is assigned the smallest possible complexity.
Note that minimizing the DNF form of a Boolean function to get an equivalent expression with the shortest number of terms, is considered a computational difficult problem and there can be multiple such minimum DNF representations for a single Boolean function.
Link operator Boolean Regulatory Functions
We consider the class of BRFs that partitions the input variables (regulators) to two sets: the set of positive regulators (also called activators) and the set of negative regulators (also called inhibitors).  The link operator BRFs have an analytical non-DNF form, which places the two distinct types of regulators in two separate expressions, while connecting them with a special logical operator that we call a link operator.
An example of such a function that has been used extensively in the logical modeling literature is the standardized BRF formula with the “AND-NOT” link operator (Mendoza and Xenarios 2006):
\[f_{AND-NOT}(x,y) = \left(\bigvee_{i=1}^{m} x_i\right) \land \lnot \left(\bigvee_{j=1}^{k} y_j\right)\]
A variation of the above function is the “OR-NOT” link operator function:
\[f_{OR-NOT}(x,y) = \left(\bigvee_{i=1}^{m} x_i\right) \lor \lnot \left(\bigvee_{j=1}^{k} y_j\right)\]
Note that the presence of the link operator is what forces the condition \(m,k \ge 1\) (at least one regulator in each category). For the rest of this work, we will not consider BRFs with only one type of regulator, since these can be represented by simple logical functions without loss of interpretability or biological consistency. Following the notation introduced in (Mendoza and Xenarios 2006), we have the case of only activators:
\[f(x)=\bigvee_{i=1}^{m} x_i\] where the presence of at least one activator makes the function output TRUE (active). Similarly, in the case of only inhibitors we have:
\[f(y)=\lnot \bigvee_{j=1}^{k} y_j=\bigwedge_{j=1}^{k} \lnot y_j\] where the presence of at least one inhibitor is enough to make the target inhibited (FALSE).
Borrowing notation from circuit theory, we could use other link operators like the NAND
, NOR
, XNOR
(\(\odot\)) gates, combined with the NOT
operator or not.
Note that the operator used to connect the same type of regulators (e.g. the activators) is usually the OR, but other operators could be used as well.
For example, another link operator function is the “Pairs” function:
\[f_{Pairs}(x,y) = \bigvee_{\forall (i,j)}^{m,k}(x_i\land \lnot y_j) = \left(\bigvee_{i=1}^{m} x_i\right) \land \left(\bigvee_{j=1}^{k} \lnot y_j\right)\]
The intuition behind the name is derived from the fact that the function will return TRUE if there is at least one pair of regulators consisting of a present activator and an absent inhibitor. The function is also expressed in conjunction normal form (CNF), which is the reverse of the DNF: two separate clauses are connected with AND’s (\(\land\)) and inside the clauses the literals are connected with OR’s (\(\lor\)).
Cury, Monteiro, and Chaouiya (2019) defined the consistent Boolean regulatory functions and their respective complete DNF forms (CDNF).
The link operator functions listed above are a subset of these functions, since they respect the regulatory structure in their respective CDNF forms (for the Pairs function it’s evident since it’s expressed first in the CDNF form - for the AND-NOT and OR-NOT functions, see their respective (complete) DNF forms in the truth density proofs 1 and 2.
Threshold functions
Boolean threshold functions are a special kind of Boolean functions for which the output depends on the condition that the sum of (possibly weighted) activities of the input regulators surpass a given threshold value (Crama and Hammer 2011).
In this work, we will use two simple threshold functions, which both output \(1\) when the number of present activators is larger than the number of present inhibitors. As such, the activators and inhibitors are combined in an additive manner, with their respective assigned weights set to \(\pm1\) and the threshold parameter to \(0\), formulating thus a majority rule which defines the value of the function (Bornholdt 2008; Chaouiya, Ourrad, and Lima 2013). These functions differ with regards to their output when there is balance between the activities of the positive and negative regulators: the first outputs \(1\) (the activators “win”) while the second outputs \(0\) (the inhibitors “win”).
\[f_{Act-win}(x,y)=\begin{cases} 1, & \text{for } \sum_{i=1}^{m} x_i \ge \sum_{j=1}^{k} y_j\\ 0, & \text{otherwise} \end{cases}\] \[f_{Inh-win}(x,y)=\begin{cases} 1, & \text{for } \sum_{i=1}^{m} x_i \gt \sum_{j=1}^{k} y_j\\ 0, & \text{otherwise} \end{cases}\]
Note that: \(f_{Inh-win}(x,y) = \lnot f_{Act-win}(y,x)\).
Note that every Boolean threshold function has an equivalent combinatorial expression and I searched for an analytic formula for the two last threshold functions. More more info, see this math.stackexchange question.


---
layout: post
title: Suite Française Storyboards
date: '2013-12-06T07:30:00+01:00'
categories:
- Suite Française
- Sketchbooks
- Storyboards
picture_url: https://film-Storyboards.tumblr.com/post/69167463572/suite-francaise-Storyboards
---
Rough Storyboards for Suite française continued.


454
In-store
{{item.price}}
MyBoutique {{item.description}}
BeckyFoster What sort of a discount will you do if we buy more than one?
NickyLaser Cool
DanKeen This looks like exactly what I have been looking for. Before I head over can I ask how many you have?


This referral requires charity care.
If a curbside is sufficient, coordinate with the TS to have Dr. Fabian see the patient.
If a complete exam is necessary, call to schedule an appointment with neurology.
The cost of a curbside is free. The cost of an appointment for patients with charity care level 1 is $15.
It takes about 6 weeks after a patient has received charity care for a neurology appointment to be scheduled. Urgent referrals can be expedited. Contact Kristen Ng if the referral is urgent and needs to be expedited.


--- layout: default title : The babel tower - Thread Dump Analyzer no_side: yes --- {% include JB/setup %} {% assign no_side = "yes" %}


Flourish is an action game, with strong inspiration from Brandish for Nippon Falcom.
You need a mouse to play.
One dwarf fell to a dungeon. The dwarf started to find the way to the ground.
Flourish is downloadable from Flourish's repository .
Run flourish
.
$ flourish
Click "Start" to start a game. Click "Quit" to close the window.
A character on the bottom side is you.
You can move by clicking inside of squares around you.

You can see your life at the upper left part in the main screen.
If you don't want to prepare to play Flourish, or when your OS is Windows, please try sumix. sumix is a 1-CD linux distribution including Flourish.
The author of Flourish is SumiTomohiko.


NOTE: All command require Voice or above in the current room, unless specified otherwise. Commands that require Voice will still work in PM for regular users.
reload [data|config]: Reloads the databases or config files of the bot. Requires either global admin or for you to be the owner of the bot.
console: Sends you a (temporary) link to the console output of the bot. Requires either global admin or for you to be the owner of the bot.
set (command) [on/off]: Turns the usage of a command on or off in this room. Requires Room Owner in the room.
leave: Makes the bot leave, and take the room off of autojoin (if autojoin is provided by inviting the bot). If the bot is set to autojoin by Config, the bot will leave, but rejoin next restart. Requires Room Owner in the room.
help (topic): Links to the bot's documentation about a certain topic. For a list of topics, use .help without a topic specified.
lastfm (username): Displays what the given last.fm username is currently listening to or has last listened to, and provides a link to their profile. If no username is provided, it will attempt to use your registered info.
registerlastfm (username): Works only in PM. This will register the given last.fm username to your PS username, and allows you to use simple .lastfm to link to your last.fm page. To update information, simply use the command again with the updated last.fm username.
moderation [on/off]: Turns moderation in this room on or off. Requires Room Owner in the room.
quote (quote): Adds the given quote to the quote page for this room. Requires Room Driver in the room.
quotes: Provides a link to the quote page of the current room.
randquote: Says a random quote from the quote page of the current room.