ESO exoskeleton, v3
At the Human/Machine Design Lab, I was tasked with developing the body attachment parts for a third-generation exoskeleton. Our goal was to create a lightweight, entirely mechanical exoskeleton (i.e. no motors or hydraulics) for paralyzed patients. Our exoskeleton had to be:
- Comfortable for extended periods of time (2-3 hours).
- Under a 20lb (9.07 kg) weight limit.
- Fit a variety of body types.
- Had to provide anklye support in the form of a platform that the patient stands on.
Technical
Unlike technical engineering problems, designing for comfortability is highly subjective from person to person. Initially, I evaluated almost a dozen current exoskeletons in other Universities. For additional reference, I read The Measure of Man: Human Factors in Design, by Henry Dreyfus.
Initial designs consisted of an aluminum bracket, surrounded by a 3D printed frame that distributed preasure along the thigh and calf. For securing limbs, 1.5” backpack strap was used. Various types of buckles were purchased for evaluation. Even with optimizing the file for strength, and increasing part density, the printed prototypes regularly broke. Instead, we pivoted towards thermoformed plastic. Glass-fiber reinforced polyethylene (PE) sheets were heated in a convection oven, then hand formed.
In all designs, high-density foam was attached to the frame using hook-and-loop (Velcro) strips.
Result
Review
What went well:
- We stayed under our 20lb weight limit, when factoring in both legs.
- Initial testing/measurement were encouraging. Coworker was able to take baby steps without using his muscles.
- Exoskeleton proved comfortable, even with hairy legs
- When I switched labs I successfully transfered my knowledge base, and a checklist of improvements to the person taking over my role.
- We were able to get the project ready in time despite an issue with a knee attachment bracket.
Not so hot:
- I was slow to adjust my long-term scheduling spreadsheet when problems arose.
- 3D printing prototypes took too long, and slowed down the cycle of testing/revising.
- I speced bolts that were overkill. There were plenty of opportunties to save even more weight.


This document describes makeheaders,
a tool that automatically generates “.h
”
files for a C or C++ programming project.
A piece of C source code can be one of two things: a declaration or a definition. A declaration is source text that gives information to the compiler but doesn't directly result in any code being generated. A definition is source text that results in executable machine instructions or initialization data. (These two terms are sometimes used inconsistently by other authors. In particular, many people reverse the meanings of these words when discussing Pascal or Ada code. The meanings described here are the same as used in the ANSI-C standards document.)
Declarations in C include things such as the following:
extern
” variable declarations.
Definitions in C, on the other hand, include these kinds of things:
The distinction between a declaration and a definition is common in modern software engineering. Another way of looking at the difference is that the declaration is the interface and the definition is the implementation.
In C programs, it has always been the tradition that declarations are
put in files with the “.h
” suffix and definitions are
placed in “.c
” files.
The .c files contain “#include
” preprocessor statements
that cause the contents of .h files to be included as part of the
source code when the .c file is compiled.
In this way, the .h files define the interface to a subsystem and
the .c files define how the subsystem is implemented.
As the art of computer programming continues to advance, and the size and complexity of programs continues to swell, the traditional C approach of placing declarations and definitions in separate files begins to present the programmer with logistics and maintenance problems. To wit:
The makeheaders program is designed to ameliorate the problems associated with the traditional C programming model by automatically generating the interface information in the .h files from interface information contained in other .h files and from implementation information in the .c files. When the makeheaders program is run, it scans the source files for a project, then generates a series of new .h files, one for each .c file. The generated .h files contain exactly those declarations required by the corresponding .c files, no more and no less.
The makeheaders programming model overcomes all of the objections to the traditional C programming model.
alpha.c
then it must include only the single .h file
named alpha.h
.
(The .c file might also use some include files from the standard
library, such as <stdio.h>
, but that is another matter.)
alpha.c
depends on alpha.h
and
nothing more.
In addition, the makeheaders program is fast and unintrusive. It is a simple matter to incorporate makeheaders into a Makefile so that makeheaders will be run automatically whenever the project is rebuilt. And the burden of running makeheaders is light. It will easily process tens of thousands of lines of source code per second.
The makeheaders program is very easy to run. If you have a collection of C source code and include files in the working directory, then you can run makeheaders to generate appropriate .h files using the following command:
makeheaders *.[ch]That's really all there is to it! This command will generate one .h file for every .c file. Any .h files that were generated by a prior run of makeheaders are ignored, but manually entered .h files that contain structure declarations and so forth will be scanned and the declarations will be copied into the generated .h files as appropriate. But if makeheaders sees that the .h file that it has generated is no different from the .h file it generated last time, it doesn't update the file. This prevents the corresponding .c files from having to be needlessly recompiled.
There are several options to the makeheaders program that can be used to alter its behavior. The default behavior is to write a single .h file for each .c file and to give the .h file the same base name as the .c file. Instead of generating a whole mess of .h files, you can, if you choose, generate a single big .h file that contains all declarations needed by all the .c files. Do this using the -h option to makeheaders. As follows:
makeheaders -h *.[ch] >common.hWith the -h option, the .h file is not actually written to a disk file but instead appears on standard output, where you are free to redirect it into the file of your choice.
A similar option is -H. Like the lower-case -h option, big -H generates a single include file on standard output. But unlike small -h, the big -H only emits prototypes and declarations that have been designated as “exportable”. The idea is that -H will generate an include file that defines the interface to a library. More will be said about this in section 3.4.
Sometimes you want the base name of the .c file and the .h file to
be different.
For example, suppose you want the include file for alpha.c
to be called beta.h
.
In this case, you would invoke makeheaders as follows:
makeheaders alpha.c:beta.hAny time a filename argument contains a colon, the name before the colon is taken to be the name of the .c file and the name after the colon is taken to be the name of the .h file. You can't use the shell's wildcard mechanism with this approach, but that normally isn't a problem in Makefiles, which is where this stuff comes in handy.
If you want a particular file to be scanned by makeheaders but you don't want makeheaders to generate a header file for that file, then you can supply an empty header filename, like this:
makeheaders alpha.c beta.c gamma.c:In this example, makeheaders will scan the three files named “
alpha.c
”,
“beta.c
” and
“gamma.c
”
but because of the colon on the end of third filename
it will only generate headers for the first two files.
Unfortunately,
it is not possible to get makeheaders to process any file whose
name contains a colon.
In a large project, the length of the command line for makeheaders
can become very long.
If the operating system doesn't support long command lines
(example: DOS and Win32) you may not be able to list all of the
input files in the space available.
In that case, you can use the “-f
” option followed
by the name of a file to cause makeheaders to read command line
options and filename from the file instead of from the command line.
For example, you might prepare a file named “mkhdr.dat
”
that contains text like this:
src/alpha.c:hdr/alpha.h src/beta.c:hdr/beta.h src/gamma.c:hdr/gamma.h ...Then invoke makeheaders as follows:
makeheaders -f mkhdr.dat
The “-local
” option causes makeheaders to
generate of prototypes for “static
” functions and
procedures.
Such prototypes are normally omitted.
Finally, makeheaders also includes a “-doc
” option.
This command line option prevents makeheaders from generating any
headers at all.
Instead, makeheaders will write to standard output
information about every definition and declaration that it encounters
in its scan of source files.
The information output includes the type of the definition or
declaration and any comment that preceeds the definition or
declaration.
The output is in a format that can be easily parsed, and is
intended to be read by another program that will generate
documentation about the program.
We'll talk more about this feature later.
If you forget what command line options are available, or forget
their exact name, you can invoke makeheaders using an unknown
command line option (like “--help
” or
“-?
”)
and it will print a summary of the available options on standard
error.
If you need to process a file whose name begins with
“-
”,
you can prepend a “./
” to its name in order to get it
accepted by the command line parser.
Or, you can insert the special option “--
” on the
command line to cause all subsequent command line arguments to be treated as
filenames even if their names begin with “-
”.
Very little has to be done to prepare source files for use with makeheaders since makeheaders will read and understand ordinary C code. But it is important that you structure your files in a way that makes sense in the makeheaders context. This section will describe several typical uses of makeheaders.
The simplest way to use makeheaders is to put all definitions in
one or more .c files and all structure and type declarations in
separate .h files.
The only restriction is that you should take care to chose basenames
for your .h files that are different from the basenames for your
.c files.
Recall that if your .c file is named (for example)
“alpha.c
”
makeheaders will attempt to generate a corresponding header file
named “alpha.h
”.
For that reason, you don't want to use that name for
any of the .h files you write since that will prevent makeheaders
from generating the .h file automatically.
The structure of a .c file intented for use with makeheaders is very
simple.
All you have to do is add a single “#include
” to the
top of the file that sources the header file that makeheaders will generate.
Hence, the beginning of a source file named “alpha.c
”
might look something like this:
/* * Introductory comment... */ #include "alpha.h" /* The rest of your code... */
Your manually generated header files require no special attention at all.
Code them as you normally would.
However, makeheaders will work better if you omit the
“#if
” statements people often put around the outside of
header files that prevent the files from being included more than once.
For example, to create a header file named “beta.h
”,
many people will habitually write the following:
#ifndef BETA_H #define BETA_H /* declarations for beta.h go here */ #endifYou can forego this cleverness with makeheaders. Remember that the header files you write will never really be included by any C code. Instead, makeheaders will scan your header files to extract only those declarations that are needed by individual .c files and then copy those declarations to the .h files corresponding to the .c files. Hence, the “
#if
” wrapper serves no useful purpose.
But it does make makeheaders work harder, forcing it to put
the statements
#if !defined(BETA_H) #endifaround every declaration that it copies out of your header file. No ill effect should come of this, but neither is there any benefit.
Having prepared your .c and .h files as described above, you can cause makeheaders to generate its .h files using the following simple command:
makeheaders *.[ch]The makeheaders program will scan all of the .c files and all of the manually written .h files and then automatically generate .h files corresponding to all .c files.
Note that
the wildcard expression used in the above example,
“*.[ch]
”,
will expand to include all .h files in the current directory, both
those entered manually be the programmer and others generated automatically
by a prior run of makeheaders.
But that is not a problem.
The makeheaders program will recognize and ignore any files it
has previously generated that show up on its input list.
The following list details all of the code constructs that makeheaders will extract and place in the automatically generated .h files:
If the “static
” keyword of C appears at the
beginning of the function definition, the prototype is suppressed.
If you use the “LOCAL
” keyword where you would normally
say “static
”, then a prototype is generated, but it
will only appear in the single header file that corresponds to the
source file containing the function. For example, if the file
alpha.c
contains the following:
LOCAL int testFunc(void){ return 0; }Then the header file
alpha.h
will contain
#define LOCAL static LOCAL int testFunc(void);However, no other generated header files will contain a prototype for
testFunc()
since the function has only file scope.
When the “LOCAL
” keyword is used, makeheaders will
also generate a #define for LOCAL, like this:
#define LOCAL staticso that the C compiler will know what it means.
If you invoke makeheaders with a “-local
”
command-line option, then it treats the “static
”
keyword like “LOCAL
” and generates prototypes in the
header file that corresponds to the source file containing the function
definition.
extern
”
declaration of that variable is placed in the header of every
.c file that uses the variable.
struct
”, “union
” or
“enum
” qualifier.
In other words, if makeheaders sees the code:
struct Examp { /* ... */ };it will automatically generate a corresponding typedef like this:
typedef struct Examp Examp;
As a final note, we observe that automatically generated declarations
are ordered as required by the ANSI-C programming language.
If the declaration of some structure “X
” requires a
prior declaration of another structure “Y
”, then Y will
appear first in the generated headers.
In my experience, large projects work better if all of the manually written code is placed in .c files and all .h files are generated automatically. This is slightly different for the traditional C method of placing the interface in .h files and the implementation in .c files, but it is a refreshing change that brings a noticable improvement to the coding experience. Others, I believe, share this view since I've noticed recent languages (ex: java, tcl, perl, awk) tend to support the one-file approach to coding as the only option.
The makeheaders program supports putting both interface and implementation into the same source file. But you do have to tell makeheaders which part of the source file is the interface and which part is the implementation. Makeheaders has to know this in order to be able to figure out whether or not structures declarations, typedefs, #defines and so forth should be copied into the generated headers of other source files.
You can instruct makeheaders to treat any part of a .c file as if it were a .h file by enclosing that part of the .c file within:
#if INTERFACE #endifThus any structure definitions that appear after the “
#if INTERFACE
” but before the corresponding
“#endif
” are eligable to be copied into the
automatically generated
.h files of other .c files.
If you use the “#if INTERFACE
” mechanism in a .c file,
then the generated header for that .c file will contain a line
like this:
#define INTERFACE 0In other words, the C compiler will never see any of the text that defines the interface. But makeheaders will copy all necessary definitions and declarations into the .h file it generates, so .c files will compile as if the declarations were really there. This approach has the advantage that you don't have to worry with putting the declarations in the correct ANSI-C order -- makeheaders will do that for you automatically.
Note that you don't have to use this approach exclusively.
You can put some declarations in .h files and others within the
“#if INTERFACE
” regions of .c files.
Makeheaders treats all declarations alike, no matter where they
come from.
You should also note that a single .c file can contain as many
“#if INTERFACE
” regions as desired.
In a large project, one will often construct a hierarchy of interfaces. For example, you may have a group of 20 or so files that form a library used in several other parts of the system. Each file in this library will present two interfaces. One interface will be the routines and data structures it is willing to share with other files in the same library, and the second interface is those routines and data structures it wishes to make available to other subsystems. (The second interface is normally a subset of the first.) Ordinary C does not provide support for a tiered interface like this, but makeheaders does.
Using makeheaders, it is possible to designate routines and data
structures as being for “export
”.
Exported objects are visible not only to other files within the
same library or subassembly but also to other
libraries and subassemblies in the larger program.
By default, makeheaders only makes objects visible to other members
of the same library.
That isn't the complete truth, actually. The semantics of C are such that once an object becomes visible outside of a single source file, it is also visible to any user of the library that is made from the source file. Makeheaders can not prevent outsiders for using non-exported resources, but it can discourage the practice by refusing to provide prototypes and declarations for the services it does not want to export. Thus the only real effect of the making an object exportable is to include it in the output makeheaders generates when it is run using the -H command line option. This is not a perfect solution, but it works well in practice.
But trouble quickly arises when we attempt to devise a mechanism for
telling makeheaders which prototypes it should export and which it should
keep local.
The built-in “static
” keyword of C works well for
prohibiting prototypes from leaving a single source file, but because C doesn't
support a linkage hierarchy, there is nothing in the C language to help us.
We'll have to invite our own keyword: “EXPORT
”
Makeheaders allows the EXPORT keyword to precede any function or procedure definition. The routine following the EXPORT keyword is then eligable to appear in the header file generated using the -H command line option. Note that if a .c file contains the EXPORT keyword, makeheaders will put the macro
#define EXPORTin the header file it generates for the .c file so that the EXPORT keyword will never be seen by the C compiler.
But the EXPORT keyword only works for function and procedure definitions. For structure, union and enum definitions, typedefs, #defines and class declarations, a second mechanism is used. Just as any declarations or definition contained within
#if INTERFACE #endifare visible to all files within the library, any declarations or definitions within
#if EXPORT_INTERFACE #endifwill become part of the exported interface. The “
#if EXPORT_INTERFACE
” mechanism can be used in
either .c or .h files.
(The “#if INTERFACE
” can also be used in both .h and
.c files, but since it's use in a .h file would be redundant, we haven't
mentioned it before.)
Structure declarations and typedefs that appear in .c files are normally
ignored by makeheaders.
Such declarations are only intended for use by the source file in which
they appear and so makeheaders doesn't need to copy them into any
generated header files.
We call such declarations “private
”.
Sometimes it is convenient to have makeheaders sort a sequence of private declarations into the correct order for us automatically. Or, we could have static functions and procedures for which we would like makeheaders to generate prototypes, but the arguments to these functions and procedures uses private declarations. In both of these cases, we want makeheaders to be aware of the private declarations and copy them into the local header file, but we don't want makeheaders to propagate the declarations outside of the file in which they are declared.
When this situation arises, enclose the private declarations within
#if LOCAL_INTERFACE #endifA “
LOCAL_INTERFACE
” block works very much like the
“INTERFACE
” and
“EXPORT_INTERFACE
”
blocks described above, except that makeheaders insures that the
objects declared in a LOCAL_INTERFACE are only visible to the
file containing the LOCAL_INTERFACE.
You can use makeheaders to generate header files for C++ code, in
addition to C.
Makeheaders will recognize and copy both “class
”
declarations
and inline function definitions, and it knows not to try to generate
prototypes for methods.
In fact, makeheaders is smart enough to be used in projects that employ a mixture of C and C++. For example, if a C function is called from within a C++ code module, makeheaders will know to prepend the text
extern "C"to the prototype for that function in the C++ header file. Going the other way, if you try to call a C++ function from within C, an appropriate error message is issued, since C++ routines can not normally be called by C code (due to fact that most C++ compilers use name mangling to facilitate type-safe linkage.)
No special command-line options are required to use makeheaders with
C++ input. Makeheaders will recognize that its source code is C++
by the suffix on the source code filename. Simple ".c" or ".h" suffixes
are assumed to be ANSI-C. Anything else, including ".cc", ".C" and
".cpp" is assumed to be C++.
The name of the header file generated by makeheaders is derived from
the name of the source file by converting every "c" to "h" and
every "C" to "H" in the suffix of the filename.
Thus the C++ source
file “alpha.cpp
” will induce makeheaders to
generate a header file named “alpha.hpp
”.
Makeheaders augments class definitions by inserting prototypes to methods where appropriate. If a method definition begins with one of the special keywords PUBLIC, PROTECTED, or PRIVATE (in upper-case to distinguish them from the regular C++ keywords with the same meaning) then a prototype for that method will be inserted into the class definition. If none of these keywords appear, then the prototype is not inserted. For example, in the following code, the constructor is not explicitly declared in the class definition but makeheaders will add it there because of the PUBLIC keyword that appears before the constructor definition.
#if INTERFACE class Example1 { private: int v1; }; #endif PUBLIC Example1::Example1(){ v1 = 0; }
The code above is equivalent to the following:
#if INTERFACE class Example1 { private: int v1; public: Example1(); }; #endif Example1::Example1(){ v1 = 0; }
The first form is preferred because only a single declaration of the constructor is required. The second form requires two declarations, one in the class definition and one on the defintion of the constructor.
Makeheaders does not understand more recent C++ syntax such as templates and namespaces. Perhaps these issues will be addressed in future revisions.
The makeheaders program understands and tracks the conditional compilation constructs in the source code files it scans. Hence, if the following code appears in a source file
#ifdef UNIX # define WORKS_WELL 1 #else # define WORKS_WELL 0 #endifthen the next patch of code will appear in the generated header for every .c file that uses the WORKS_WELL constant:
#if defined(UNIX) # define WORKS_WELL 1 #endif #if !defined(UNIX) # define WORKS_WELL 0 #endifThe conditional compilation constructs can be nested to any depth. Makeheaders also recognizes the special case of
#if 0 #endifand treats the enclosed text as a comment.
The makeheaders system is designed to be robust but it is possible for a devious programmer to fool the system, usually with unhelpful consequences. This subsection is a guide to helping you avoid trouble.
Makeheaders does not understand the old K&R style of function and procedure definitions. It only understands the modern ANSI-C style, and will probably become very confused if it encounters an old K&R function. Therefore you should take care to avoid putting K&R function definitions in your code.
Makeheaders does not understand when you define more than one global variable with the same type separated by a comma. In other words, makeheaders does not understand this:
int a = 4, b = 5;The makeheaders program wants every variable to have its own definition. Like this:
int a = 4; int b = 5;Notice that this applies to global variables only, not to variables you declare inside your functions. Since global variables ought to be exceedingly rare, and since it is good style to declare them separately anyhow, this restriction is not seen as a terrible hardship.
Makeheaders does not support defining an enumerated or aggregate type in the same statement as a variable declaration. None of the following statements work completely:
struct {int field;} a; struct Tag {int field;} b; struct Tag c;Instead, define types separately from variables:
#if INTERFACE struct Tag {int field;}; #endif Tag a; Tag b; /* No more than one variable per declaration. */ Tag c; /* So must put each on its own line. */See 3.2 What Declarations Get Copied for details, including on the automatic typedef.
The makeheaders program processes its source file prior to sending those files through the C preprocessor. Hence, if you hide important structure information in preprocessor defines, makeheaders might not be able to successfully extract the information it needs from variables, functions and procedure definitions. For example, if you write this:
#define BEGIN { #define END }at the beginning of your source file, and then try to create a function definition like this:
char *StrDup(const char *zSrc) BEGIN /* Code here */ ENDthen makeheaders won't be able to find the end of the function definition and bad things are likely to happen.
For most projects the code constructs that makeheaders cannot handle are very rare. As long as you avoid excessive cleverness, makeheaders will probably be able to figure out what you want and will do the right thing.
Makeheaders has limited understanding of enums. In particular, it does
not realize the significance of enumerated values, so the enum is not
emitted in the header files when its enumerated values are used unless
the name associated with the enum is also used. Moreover, enums can be
completely anonymous, e.g. “enum {X, Y, Z};
”.
Makeheaders ignores such enums so they can at least be used within a
single source file. Makeheaders expects you to use #define constants
instead. If you want enum features that #define lacks, and you need the
enum in the interface, bypass makeheaders and write a header file by
hand, or teach makeheaders to emit the enum definition when any of the
enumerated values are used, rather than only when the top-level name (if
any) is used.
Many people have observed the advantages of generating program documentation directly from the source code:
When makeheaders is run with the “-doc
” option, it
emits no header files at all.
Instead, it does a complete dump of its internal tables to standard
output in a form that is easily parsed.
This output can then be used by another program (the implementation
of which is left as an exercise to the reader) that will use the
information to prepare suitable documentation.
The “-doc
” option causes makeheaders to print
information to standard output about all of the following objects:
#define
”)
#if
”) then the text of that conditional is
provided.
The source code for makeheaders is a single file of ANSI-C code, approximately 3000 lines in length. The program makes only modest demands of the system and C library and should compile without alteration on most ANSI C compilers and on most operating systems. It is known to compile using several variations of GCC for Unix as well as Cygwin32 and MSVC 5.0 for Win32.
The makeheaders program was first written by D. Richard Hipp (also the original author of SQLite and Fossil) in 1993. Hipp open-sourced the project immediately, but it never caught on with any other developers and it continued to be used mostly by Hipp himself for over a decade. When Hipp was first writing the Fossil version control system in 2006 and 2007, he used makeheaders on that project to help simplify the source code. As the popularity of Fossil increased, the makeheaders that was incorporated into the Fossil source tree became the "official" makeheaders implementation.
As this paragraph is being composed (2016-11-05), Fossil is the only project known to Hipp that is still using makeheaders. On the other hand, makeheaders has served the Fossil project well and there are no plans remove it.
The makeheaders program will automatically generate a minimal header file for each of a set of C source and header files, and will generate a composite header file for the entire source file suite, for either internal or external use. It can also be used as the parser in an automated program documentation system.
The makeheaders program has been in use since 1994, in a wide variety of projects under both UNIX and Win32. In every project where it has been used, makeheaders has proven to be a very helpful aid in the construction and maintenance of large C codes. In at least two cases, makeheaders has facilitated development of programs that would have otherwise been all but impossible due to their size and complexity.


| java.lang.Object | |
| ↳ | com.shinobicontrols.charts.CrosshairStyle |
Visual style properties for a chart's Crosshair
. If you make any
styling changes after the chart has been displayed, you should call
chart.redrawChart().
| Public Constructors | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| Public Methods | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
Returns the
int representation of the color of the crosshair
lines that extend from the target circle to the axis edges. | |||||||||||
Returns the width of the crosshair lines that extend from the target
circle to the axis edges.
| |||||||||||
Returns the
int representation of the background color of the
tooltip | |||||||||||
Returns the
int representation of the color for the tooltip's
border. | |||||||||||
Returns the width of the tooltip's border, in device independent pixels.
| |||||||||||
Returns the corner radius of the tooltip, in device independent pixels.
| |||||||||||
Returns the
int representation of the background color of the
label in the tooltip. | |||||||||||
Returns the amount of padding in the crosshair's tooltip, in device
independent pixels.
| |||||||||||
Returns the
int representation of the color of the text in the
tooltip. | |||||||||||
Returns the size of the text in the tooltip, in scaled pixels.
| |||||||||||
Returns the
Typeface of the text in the tooltip. | |||||||||||
Sets the color of the crosshair lines that extend from the target circle
to the axis edges.
| |||||||||||
Sets the width of the crosshair lines that extend from the target circle
to the axis edges.
| |||||||||||
Sets the background color for the tooltip
| |||||||||||
Sets the color for the tooltip's border.
| |||||||||||
Sets the width for the tooltip's border, in device independent pixels.
| |||||||||||
Sets the corner radius for the tooltip, in device independent pixels.
| |||||||||||
Sets the background color for the label in the tooltip.
| |||||||||||
Sets the amount of padding for the crosshair's tooltip, in device
independent pixels.
| |||||||||||
Sets the color for the text in the tooltip.
| |||||||||||
Sets the size for the text in the tooltip, in scaled pixels.
| |||||||||||
Sets the
Typeface for the text in the tooltip. |
|
[Expand]
Inherited Methods | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
|
From class
java.lang.Object
|
Returns the int
representation of the color of the crosshair
lines that extend from the target circle to the axis edges.
int
representation of the color of the crosshair
linesReturns the width of the crosshair lines that extend from the target circle to the axis edges. In device independent pixels.
Returns the int
representation of the background color of the
tooltip
int
representation of the background color of the
tooltipReturns the int
representation of the color for the tooltip's
border.
int
representation of the color for the tooltip's
border
Returns the width of the tooltip's border, in device independent pixels.
Returns the corner radius of the tooltip, in device independent pixels.
Returns the int
representation of the background color of the
label in the tooltip.
int
representation of the background color of the
label in the tooltipReturns the amount of padding in the crosshair's tooltip, in device independent pixels.
Returns the int
representation of the color of the text in the
tooltip.
int
representation of the color of the text in the
tooltipReturns the size of the text in the tooltip, in scaled pixels.
Returns the Typeface
of the text in the tooltip.
Sets the color of the crosshair lines that extend from the target circle to the axis edges.
| lineColor | the int representation of the color for the
crosshair lines |
|---|
Sets the width of the crosshair lines that extend from the target circle to the axis edges. In device independent pixels.
| lineWidth | the width for the crosshair lines |
|---|
Sets the background color for the tooltip
| tooltipBackgroundColor | the int representation of the
background color for the tooltip |
|---|
Sets the color for the tooltip's border.
| tooltipBorderColor | the int representation of the color for
the tooltip's border
|
|---|
Sets the width for the tooltip's border, in device independent pixels.
| tooltipBorderWidth | the width for the tooltip's border, in device independent pixels |
|---|
Sets the corner radius for the tooltip, in device independent pixels.
| tooltipCornerRadius | the corner radius for the tooltip, in device independent pixels. |
|---|
Sets the background color for the label in the tooltip.
| tooltipLabelBackgroundColor | the int representation of the
background color for the label in the tooltip |
|---|
Sets the amount of padding for the crosshair's tooltip, in device independent pixels.
| tooltipPadding | the amount of padding for the crosshair's tooltip, in device independent pixels |
|---|
Sets the color for the text in the tooltip.
| tooltipTextColor | the int representation of the color for
the text in the tooltip |
|---|
Sets the size for the text in the tooltip, in scaled pixels.
| tooltipTextSize | the size for the text in the tooltip, in scaled pixels |
|---|
Sets the Typeface
for the text in the tooltip.
| tooltipTypeface | the typeface for the text in the tooltip |
|---|


Inspector Adler:
We really don't know what you will encounter when you open the gateway to Pailaka. But as with Kamaloka, I suspect you will find an ally there willing to share information.
You should have no difficulty learning what you must do.
Good luck!
Accept the challenge of Pailaka.


Tests the image for an accessible name
Text alternatives are meaningful
Image accessible name does not contain file name
Tests that accessible image name is less than 100 characters
Verify images are decorative
Long descriptions


Account Age Filter
Choose an age limit:
Years
Months
Days
Select options
Hide entries from users under age limit
Hide replies to entries as well
Display users' age
Add colors to users' age element


The content for Bedtime Story Teller has been developed by Ameer Dawood. However, Bedtime Story Teller runs on systems provided by Google, and Ameer Dawood does not have full access to the app. In particular, Ameer Dawood has no ability to access the messages you send to Bedtime Story Teller or the responses that it sends back to you.
Ameer Dawood may receive from Google non-personally identifying information about the use of Bedtime Story Teller. For instance, Ameer Dawood can access usage information regarding how many users are using the app, which geographical regions they are located in, and basic data including users’ language, device type, and length and frequency of use. None of the information Ameer Dawood receives from Google identifies you, nor does it reveal to Ameer Dawood what information you sent to the app or what specific responses the app sent to you.
When you use Bedtime Story Teller, you are also using the Google Assistant, and the Google Privacy Policy describes how Google collects and uses data about your use of the app. You may wish to consult Google’s documentation regarding what information is shared with your Google Assistant and how to delete your Google Assistant activity.
Ameer Dawood may, in the future, modify Bedtime Story Teller to run on infrastructure which Ameer Dawood has full access to, which would allow Ameer Dawood access to additional information about your interaction with the app. Should that occur, Ameer Dawood will comply with its obligations under applicable privacy law, including updating this Privacy Policy as required.
Open on Assistant Directory


@() @import views.support.Zurb._ @fullRow(Seq("social__links")) { @fragments.inlineSvg("fb", "icon") 5.4m @fragments.inlineSvg("twitter-bird", "icon") 5.2m @fragments.inlineSvg("instagram", "icon") 272k } @fullRow(Seq("email__links")) { Manage your emails | Unsubscribe } @fullRow(Seq("disclaimer")) {
You are receiving this email because you are a subscriber to The Fiver. Guardian News & Media Limited - a member of Guardian Media Group PLC. Registered Office: Kings Place, 90 York Way, London, N1 9GU. Registered in England No. 908396
}


| Global Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (427 entries) |
| Notation Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (8 entries) |
| Variable Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (1 entry) |
| Library Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (41 entries) |
| Axiom Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (199 entries) |
| Lemma Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (41 entries) |
| Constructor Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (6 entries) |
| Inductive Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (3 entries) |
| Instance Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (7 entries) |
| Section Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (11 entries) |
| Definition Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (110 entries) |
Global Index
A
acc [definition, in voting]acc_cong [axiom, in morphisms]
acc1 [definition, in voting]
acc2 [definition, in voting]
agentDist1 [axiom, in foo_axioms]
agentDist2 [axiom, in foo_axioms]
agentDist3 [axiom, in foo_axioms]
andbprops [library]
andB_cong [axiom, in morphisms]
andB_TRue_iff [lemma, in andbprops]
andB_TRue_intro [lemma, in andbprops]
andB_prop [axiom, in andbprops]
andB_assoc [axiom, in andbprops]
andB_assoc1 [lemma, in andbprops]
andB_comm [axiom, in andbprops]
andB_comm1 [lemma, in andbprops]
andB_notb_r [lemma, in andbprops]
andB_TRue_l [lemma, in andbprops]
andB_TRue_r [lemma, in andbprops]
andB_diag [lemma, in andbprops]
andB_FAlse_l [lemma, in andbprops]
andB_FAlse_r [lemma, in andbprops]
andB_FAlse_intro2 [lemma, in andbprops]
andB_FAlse_intro1 [lemma, in andbprops]
andb_props [section, in andbprops]
andNotb [axiom, in prop1]
and_notB_l [lemma, in andbprops]
and_notB_r [lemma, in andbprops]
app_EQI_Cong [axiom, in morphisms]
app_EQml_Cong [axiom, in morphisms]
aux_axioms [section, in axioms]
Avote [definition, in voting]
axioms [library]
B
b [definition, in voteprivacy]bcheck [definition, in voting]
beqnat [definition, in tactics]
beqnat_assns [definition, in tactics]
bk [definition, in voting]
blindness [axiom, in foo_axioms]
blind_cong [axiom, in morphisms]
BolEQ [axiom, in morphisms]
bol_Cong [axiom, in morphisms]
Bol_Equ_Equiv [instance, in morphisms]
bsign_cong [axiom, in morphisms]
bver_cong [axiom, in morphisms]
Bvote [definition, in voting]
b1_notb2 [lemma, in andbprops]
C
c [definition, in voteprivacy]candEql1 [axiom, in foo_axioms]
candEql2 [axiom, in foo_axioms]
candEql3 [axiom, in foo_axioms]
checkostmylis [definition, in tactics]
checksublis [definition, in tactics]
checksublis' [definition, in tactics]
closMylist_split [axiom, in prop1]
clos_subbol_cong [axiom, in morphisms]
commEql [axiom, in foo_axioms]
commKeyEql [axiom, in foo_axioms]
comm_cong [axiom, in morphisms]
compHid [axiom, in foo_axioms]
compHid_ext [axiom, in foo_axioms]
core_axioms.ifbranch [section, in axioms]
[[ _ ]] (msg_scope) [notation, in axioms]
core_axioms.restr [section, in axioms]
core_axioms.funapp [section, in axioms]
core_axioms [section, in axioms]
correctness [axiom, in axioms]
cpacca [library]
cpdt [library]
D
d [definition, in voting]dec_cong [axiom, in morphisms]
definitions [library]
dist [definition, in voting]
distbb [definition, in voting]
dist1 [definition, in voting]
dist2 [definition, in voting]
ds_axioms [section, in axioms]
DupBoolCond [axiom, in prop1]
E
e [definition, in voting]eltPos' [definition, in tactics]
enc_cong [axiom, in morphisms]
EQb [definition, in morphisms]
eqb_cong [axiom, in morphisms]
EQb_trans [lemma, in morphisms]
EQb_ref [lemma, in morphisms]
EQb_sym [lemma, in morphisms]
eqb1 [constructor, in morphisms]
EQCONG_B [axiom, in axioms]
EQCONG_M [axiom, in axioms]
eqconm [constructor, in morphisms]
eqconos [constructor, in morphisms]
EQI [axiom, in morphisms]
EQI_trans [lemma, in morphisms]
EQI_sym [lemma, in morphisms]
EQI_ref [lemma, in morphisms]
EQI_Equiv [instance, in morphisms]
EQI_equiv [axiom, in morphisms]
eqlistm_ind' [lemma, in morphisms]
eqlistm_ind [axiom, in morphisms]
eqlistos_ind [axiom, in morphisms]
EQlm [inductive, in morphisms]
EQlm_equiv [axiom, in morphisms]
EQlm_Equ_Equiv [axiom, in morphisms]
eql_cong [axiom, in morphisms]
EQm [definition, in morphisms]
eqmeq [axiom, in prop1]
eqmeql [axiom, in axioms]
eqmeql [lemma, in prop1]
EQml [definition, in morphisms]
eqm_cong [axiom, in morphisms]
EQm_trans [lemma, in morphisms]
EQm_sym [lemma, in morphisms]
EQm_ref [lemma, in morphisms]
EQm_Equiv [instance, in morphisms]
EQm_equiv [axiom, in morphisms]
eqm_refl [axiom, in voteprivacy]
eqm_refl [axiom, in voteprivacy]
eqm1 [constructor, in morphisms]
eqnm [constructor, in morphisms]
eqnos [constructor, in morphisms]
EQos [inductive, in morphisms]
EQosl [inductive, in morphisms]
EQos_trans [lemma, in morphisms]
EQos_ref [lemma, in morphisms]
EQos_sym [lemma, in morphisms]
eqtheory [section, in axioms]
eq_msg_mylist_cong [axiom, in morphisms]
existsnBlist [axiom, in axioms]
existsnMlist [axiom, in axioms]
existsnMylist [axiom, in axioms]
ex5_4_IFTF [library]
ex5_4_IFIDEMP [library]
ex5_4_IFMORPH [library]
ex7_4 [library]
e1 [definition, in voting]
F
fintrm [definition, in voting]foo_axioms [section, in foo_axioms]
foo_imp1 [library]
foo_prot21 [library]
foo_prot1 [library]
foo_prot2 [library]
foo_axioms [library]
foo_prot3 [library]
foo_phase2_imp1 [library]
foo_prot [library]
Forall_ELM_EVAL_B3 [axiom, in axioms]
Forall_ELM_EVAL_M3 [axiom, in axioms]
Forall_ELM_EVAL_B2 [axiom, in axioms]
Forall_ELM_EVAL_M2 [axiom, in axioms]
Forall_ELM_EVAL_B1 [axiom, in axioms]
Forall_ELM_EVAL_M1 [axiom, in axioms]
Forall_ELM_EVAL_B [axiom, in axioms]
Forall_ELM_EVAL_M [axiom, in axioms]
frame1_ind [lemma, in voteprivacy]
frame2_ind [lemma, in voteprivacy]
frame3 [library]
frame4 [library]
frame5 [library]
FRESHIND [axiom, in axioms]
FRESHIND_rs [axiom, in axioms]
FRESHNEQ [axiom, in axioms]
fresh_split [axiom, in prop1]
funapptrm [axiom, in tactics]
FUNCAPP [axiom, in axioms]
FUNCApp_pi2 [axiom, in axioms]
FUNCApp_pi1 [axiom, in axioms]
FUNCApp_pair [axiom, in axioms]
FUNCApp_notB [axiom, in axioms]
FUNCApp_andB [axiom, in axioms]
FUNCApp_O [axiom, in axioms]
FUNCApp_to [axiom, in axioms]
FUNCApp_ifmpair [axiom, in axioms]
FUNCApp_ifmnespair [axiom, in axioms]
FUNCApp_negpos [axiom, in axioms]
FUNCApp_eqb [axiom, in axioms]
FUNCApp_eqm [axiom, in axioms]
FUNCApp_appelt [axiom, in axioms]
FUNCApp_const [axiom, in axioms]
FUNCApp_sublist [axiom, in axioms]
FUNCApp_g3 [axiom, in axioms]
FUNCApp_g2 [axiom, in axioms]
FUNCApp_f4mb [axiom, in axioms]
FUNCApp_f4m [axiom, in axioms]
FUNCApp_f4b [axiom, in axioms]
FUNCApp_f3m [axiom, in axioms]
FUNCApp_f3bm [axiom, in axioms]
FUNCApp_f3b [axiom, in axioms]
FUNCApp_f2m [axiom, in axioms]
FUNCApp_f2b [axiom, in axioms]
FUNCApp_f1 [axiom, in axioms]
FUNCApp_bconst [axiom, in axioms]
FUNCApp_mconst [axiom, in axioms]
FUNCApp_att4 [axiom, in axioms]
f_cong [axiom, in morphisms]
f_cong_l [axiom, in morphisms]
G
gen_ifmf_f2' [axiom, in prop1]gen_ifmf_bol_f2 [axiom, in prop1]
gen_ifmf_f2 [axiom, in prop1]
gen_ifmf_f1 [axiom, in prop1]
I
IFBRANCH_M10 [axiom, in axioms]IFBRANCH_M9 [axiom, in axioms]
IFBRANCH_M8 [axiom, in axioms]
IFBRANCH_M7 [axiom, in axioms]
IFBRANCH_M6 [axiom, in axioms]
IFBRANCH_M5 [axiom, in axioms]
IFBRANCH_M4 [axiom, in axioms]
IFBRANCH_M3 [axiom, in axioms]
IFBRANCH_M2 [axiom, in axioms]
IFBRANCH_M1 [axiom, in axioms]
IFBRANCH_M1' [axiom, in prop1]
IFB_cong [axiom, in morphisms]
IFDIST [axiom, in axioms]
IFEVAL_M' [axiom, in axioms]
IFEVAL_B' [axiom, in axioms]
IFEVAL_M [axiom, in axioms]
IFEVAL_B [axiom, in axioms]
IFFALSE_B [axiom, in axioms]
IFFALSE_M [axiom, in axioms]
IFIDEMP_B [lemma, in andbprops]
IFMORPH_B2 [lemma, in andbprops]
IFMORPH_B1 [lemma, in andbprops]
IFM_cong [axiom, in morphisms]
IFSAME_B [axiom, in axioms]
IFSAME_M [axiom, in axioms]
IFTF [axiom, in andbprops]
IFTF [lemma, in prop1]
IFTFb [lemma, in prop1]
IFTRUE_B [axiom, in axioms]
IFTRUE_M [axiom, in axioms]
imp1_phase1 [library]
imp1_phase2 [library]
invarsub_mmsg [axiom, in axioms]
invarsub_mBool [axiom, in axioms]
invarsub_BBool [axiom, in axioms]
invarsub_Bmsg [axiom, in axioms]
isin [definition, in voting]
K
k [definition, in foo_axioms]kb_cong [axiom, in morphisms]
kc_cong [axiom, in morphisms]
ke_cong [axiom, in morphisms]
ks_cong [axiom, in morphisms]
k0 [definition, in voteprivacy]
k1 [definition, in voteprivacy]
L
label [definition, in voting]len [axiom, in axioms]
len_mylist [definition, in tactics]
lm_Eqlm_Equiv [instance, in morphisms]
L_cong [axiom, in morphisms]
M
mapsubtrmls [definition, in tactics]mchecks [definition, in voting]
ml_Equ_Equiv [instance, in morphisms]
ml_EQI_Cong [axiom, in morphisms]
morphisms [library]
msg_Cong [axiom, in morphisms]
msg_beq_refl [axiom, in prop1]
N
neg_inv [axiom, in prop1]notb_cong [axiom, in morphisms]
notb_FAlse_iff [lemma, in andbprops]
notB_TRue_iff [lemma, in andbprops]
notB_involutive [lemma, in andbprops]
notoccn_msg [axiom, in axioms]
notoccn_Bool [axiom, in axioms]
notocc_bolbm [axiom, in axioms]
notocc_bolmb [axiom, in axioms]
notocc_bolbb [axiom, in axioms]
notocc_bolmm [axiom, in axioms]
O
occurNlist [definition, in axioms]open_cong [axiom, in morphisms]
osl_Equ_Equiv [instance, in morphisms]
os_cong [axiom, in morphisms]
os_Equ_Equiv [instance, in morphisms]
P
p [definition, in voting]pairEql [axiom, in foo_axioms]
pair_cong [axiom, in morphisms]
pchecks [definition, in voting]
phaseDist [axiom, in foo_axioms]
phaseEql [axiom, in foo_axioms]
phase21 [library]
phase21' [library]
phase22 [library]
phase22' [library]
phase23 [library]
phase23' [library]
phase3 [library]
phase31 [library]
phase31' [library]
phase32 [library]
phase32' [library]
phase33 [library]
phase33' [library]
phi0 [definition, in voteprivacy]
phi1 [definition, in voteprivacy]
phi2 [definition, in voteprivacy]
phi3 [definition, in voting]
phi4 [definition, in voting]
phi5 [definition, in voting]
phi6 [definition, in voting]
phi7 [definition, in voting]
phi8 [definition, in voting]
pi1_cong [axiom, in morphisms]
pi2_cong [axiom, in morphisms]
pk [definition, in voteprivacy]
porp [lemma, in prop1]
proj1 [axiom, in axioms]
proj2 [axiom, in axioms]
prop [section, in prop1]
prop1 [library]
pubkey_cong [axiom, in morphisms]
R
r [definition, in axioms]r [definition, in foo_axioms]
rb_cong [axiom, in morphisms]
rb0 [definition, in voteprivacy]
rb1 [definition, in voteprivacy]
REFL [axiom, in axioms]
rep_nonce [axiom, in prop1]
rep_name [axiom, in prop1]
RESTR [axiom, in axioms]
restr_sublis [axiom, in tactics]
RESTR_rev [axiom, in tactics]
RESTR_swapls [axiom, in axioms]
RESTR_swap [axiom, in axioms]
RESTR_dropone [axiom, in axioms]
RESTR_dropls [axiom, in axioms]
RESTR_proj [axiom, in axioms]
re_cong [axiom, in morphisms]
rs_cong [axiom, in morphisms]
rs0 [definition, in voteprivacy]
rs1 [definition, in voteprivacy]
S
s [definition, in voteprivacy]se [definition, in voting]
shuffle1 [axiom, in foo_axioms]
shuffle2 [axiom, in foo_axioms]
shuffle3 [axiom, in foo_axioms]
shuffle4 [axiom, in foo_axioms]
shuffle5 [axiom, in foo_axioms]
shuffle6 [axiom, in foo_axioms]
shufl_cong [axiom, in morphisms]
sign_cong [axiom, in morphisms]
split_eqm [axiom, in prop1]
split_fresh [axiom, in prop1]
ssk [definition, in voteprivacy]
ssk0 [definition, in voteprivacy]
ssk1 [definition, in voteprivacy]
strm [definition, in voting]
sublisIndcs [definition, in tactics]
sublisIndcs' [definition, in tactics]
substbl_msg_cong [axiom, in morphisms]
substbl_bl_cong [axiom, in morphisms]
substmsg_msg_cong [axiom, in morphisms]
substmsg_Bool_cong [axiom, in morphisms]
subtrmls_mylis'' [definition, in tactics]
subtrmls_os'' [definition, in tactics]
subtrmls_msg'' [definition, in tactics]
subtrmls_bol'' [definition, in tactics]
subtrm' [section, in tactics]
subtrm'.f [variable, in tactics]
swapElseBranches [axiom, in prop1]
SYM [axiom, in axioms]
T
tactics [library]tau [definition, in voting]
theta [definition, in voteprivacy]
theta21 [definition, in voting]
theta23 [definition, in voting]
topsybol_beq [definition, in tactics]
topsymsg_beq [definition, in tactics]
topsyos_beq [definition, in tactics]
to_cong [axiom, in morphisms]
tr [definition, in voteprivacy]
TRANS [axiom, in axioms]
true_ident [lemma, in prop1]
t1 [definition, in voteprivacy]
t2 [definition, in voteprivacy]
t3 [definition, in voting]
t4 [definition, in voting]
t4s [definition, in voting]
t4ss [definition, in voting]
t47 [definition, in voting]
t48 [definition, in voting]
t5 [definition, in voting]
t61 [definition, in voting]
t61s [definition, in voting]
t61ss [definition, in voting]
t62 [definition, in voting]
t62s [definition, in voting]
t62ss [definition, in voting]
t71 [definition, in voting]
t71s [definition, in voting]
t72 [definition, in voting]
t72s [definition, in voting]
U
ubEql [axiom, in foo_axioms]ubNotUndefined [axiom, in foo_axioms]
ubNotUndefined_ext [axiom, in prop1]
UFCMA [axiom, in axioms]
unblind_cong [axiom, in morphisms]
unforgb [definition, in axioms]
V
v [definition, in voteprivacy]vcheck [definition, in voteprivacy]
ver_cong [axiom, in morphisms]
voteprivacy [library]
vote_len_eql [axiom, in prop1]
vote_len_reg [axiom, in voteprivacy]
voting [library]
votingProofs [library]
V0_cong [axiom, in morphisms]
V1_cong [axiom, in morphisms]
X
x1 [definition, in voteprivacy]x2ft [definition, in voteprivacy]
x2t [definition, in voteprivacy]
x3ftt [definition, in voting]
x3tt [definition, in voting]
x4fttt [definition, in voting]
x4ttt [definition, in voting]
x5ft [definition, in voting]
x5t [definition, in voting]
x6ft [definition, in voting]
x6t [definition, in voting]
x7ft [definition, in voting]
x7t [definition, in voting]
x8ft [definition, in voting]
x8t [definition, in voting]
other
_ == _ (ind_scope) [notation, in morphisms]_ #@ _ (ind_scope) [notation, in morphisms]
_ #### _ (ind_scope) [notation, in morphisms]
_ ### _ (ind_scope) [notation, in morphisms]
_ # _ (ind_scope) [notation, in morphisms]
_ ~ _ (ind_scope) [notation, in morphisms]
_ ## _ (msg_scope) [notation, in morphisms]
Notation Index
C
[[ _ ]] (msg_scope) [in axioms]other
_ == _ (ind_scope) [in morphisms]_ #@ _ (ind_scope) [in morphisms]
_ #### _ (ind_scope) [in morphisms]
_ ### _ (ind_scope) [in morphisms]
_ # _ (ind_scope) [in morphisms]
_ ~ _ (ind_scope) [in morphisms]
_ ## _ (msg_scope) [in morphisms]
Variable Index
S
subtrm'.f [in tactics]Library Index
A
andbpropsaxioms
C
cpaccacpdt
D
definitionsE
ex5_4_IFTFex5_4_IFIDEMP
ex5_4_IFMORPH
ex7_4
F
foo_imp1foo_prot21
foo_prot1
foo_prot2
foo_axioms
foo_prot3
foo_phase2_imp1
foo_prot
frame3
frame4
frame5
I
imp1_phase1imp1_phase2
M
morphismsP
phase21phase21'
phase22
phase22'
phase23
phase23'
phase3
phase31
phase31'
phase32
phase32'
phase33
phase33'
prop1
T
tacticsV
voteprivacyvoting
votingProofs
Axiom Index
A
acc_cong [in morphisms]agentDist1 [in foo_axioms]
agentDist2 [in foo_axioms]
agentDist3 [in foo_axioms]
andB_cong [in morphisms]
andB_prop [in andbprops]
andB_assoc [in andbprops]
andB_comm [in andbprops]
andNotb [in prop1]
app_EQI_Cong [in morphisms]
app_EQml_Cong [in morphisms]
B
blindness [in foo_axioms]blind_cong [in morphisms]
BolEQ [in morphisms]
bol_Cong [in morphisms]
bsign_cong [in morphisms]
bver_cong [in morphisms]
C
candEql1 [in foo_axioms]candEql2 [in foo_axioms]
candEql3 [in foo_axioms]
closMylist_split [in prop1]
clos_subbol_cong [in morphisms]
commEql [in foo_axioms]
commKeyEql [in foo_axioms]
comm_cong [in morphisms]
compHid [in foo_axioms]
compHid_ext [in foo_axioms]
correctness [in axioms]
D
dec_cong [in morphisms]DupBoolCond [in prop1]
E
enc_cong [in morphisms]eqb_cong [in morphisms]
EQCONG_B [in axioms]
EQCONG_M [in axioms]
EQI [in morphisms]
EQI_equiv [in morphisms]
eqlistm_ind [in morphisms]
eqlistos_ind [in morphisms]
EQlm_equiv [in morphisms]
EQlm_Equ_Equiv [in morphisms]
eql_cong [in morphisms]
eqmeq [in prop1]
eqmeql [in axioms]
eqm_cong [in morphisms]
EQm_equiv [in morphisms]
eqm_refl [in voteprivacy]
eqm_refl [in voteprivacy]
eq_msg_mylist_cong [in morphisms]
existsnBlist [in axioms]
existsnMlist [in axioms]
existsnMylist [in axioms]
F
Forall_ELM_EVAL_B3 [in axioms]Forall_ELM_EVAL_M3 [in axioms]
Forall_ELM_EVAL_B2 [in axioms]
Forall_ELM_EVAL_M2 [in axioms]
Forall_ELM_EVAL_B1 [in axioms]
Forall_ELM_EVAL_M1 [in axioms]
Forall_ELM_EVAL_B [in axioms]
Forall_ELM_EVAL_M [in axioms]
FRESHIND [in axioms]
FRESHIND_rs [in axioms]
FRESHNEQ [in axioms]
fresh_split [in prop1]
funapptrm [in tactics]
FUNCAPP [in axioms]
FUNCApp_pi2 [in axioms]
FUNCApp_pi1 [in axioms]
FUNCApp_pair [in axioms]
FUNCApp_notB [in axioms]
FUNCApp_andB [in axioms]
FUNCApp_O [in axioms]
FUNCApp_to [in axioms]
FUNCApp_ifmpair [in axioms]
FUNCApp_ifmnespair [in axioms]
FUNCApp_negpos [in axioms]
FUNCApp_eqb [in axioms]
FUNCApp_eqm [in axioms]
FUNCApp_appelt [in axioms]
FUNCApp_const [in axioms]
FUNCApp_sublist [in axioms]
FUNCApp_g3 [in axioms]
FUNCApp_g2 [in axioms]
FUNCApp_f4mb [in axioms]
FUNCApp_f4m [in axioms]
FUNCApp_f4b [in axioms]
FUNCApp_f3m [in axioms]
FUNCApp_f3bm [in axioms]
FUNCApp_f3b [in axioms]
FUNCApp_f2m [in axioms]
FUNCApp_f2b [in axioms]
FUNCApp_f1 [in axioms]
FUNCApp_bconst [in axioms]
FUNCApp_mconst [in axioms]
FUNCApp_att4 [in axioms]
f_cong [in morphisms]
f_cong_l [in morphisms]
G
gen_ifmf_f2' [in prop1]gen_ifmf_bol_f2 [in prop1]
gen_ifmf_f2 [in prop1]
gen_ifmf_f1 [in prop1]
I
IFBRANCH_M10 [in axioms]IFBRANCH_M9 [in axioms]
IFBRANCH_M8 [in axioms]
IFBRANCH_M7 [in axioms]
IFBRANCH_M6 [in axioms]
IFBRANCH_M5 [in axioms]
IFBRANCH_M4 [in axioms]
IFBRANCH_M3 [in axioms]
IFBRANCH_M2 [in axioms]
IFBRANCH_M1 [in axioms]
IFBRANCH_M1' [in prop1]
IFB_cong [in morphisms]
IFDIST [in axioms]
IFEVAL_M' [in axioms]
IFEVAL_B' [in axioms]
IFEVAL_M [in axioms]
IFEVAL_B [in axioms]
IFFALSE_B [in axioms]
IFFALSE_M [in axioms]
IFM_cong [in morphisms]
IFSAME_B [in axioms]
IFSAME_M [in axioms]
IFTF [in andbprops]
IFTRUE_B [in axioms]
IFTRUE_M [in axioms]
invarsub_mmsg [in axioms]
invarsub_mBool [in axioms]
invarsub_BBool [in axioms]
invarsub_Bmsg [in axioms]
K
kb_cong [in morphisms]kc_cong [in morphisms]
ke_cong [in morphisms]
ks_cong [in morphisms]
L
len [in axioms]L_cong [in morphisms]
M
ml_EQI_Cong [in morphisms]msg_Cong [in morphisms]
msg_beq_refl [in prop1]
N
neg_inv [in prop1]notb_cong [in morphisms]
notoccn_msg [in axioms]
notoccn_Bool [in axioms]
notocc_bolbm [in axioms]
notocc_bolmb [in axioms]
notocc_bolbb [in axioms]
notocc_bolmm [in axioms]
O
open_cong [in morphisms]os_cong [in morphisms]
P
pairEql [in foo_axioms]pair_cong [in morphisms]
phaseDist [in foo_axioms]
phaseEql [in foo_axioms]
pi1_cong [in morphisms]
pi2_cong [in morphisms]
proj1 [in axioms]
proj2 [in axioms]
pubkey_cong [in morphisms]
R
rb_cong [in morphisms]REFL [in axioms]
rep_nonce [in prop1]
rep_name [in prop1]
RESTR [in axioms]
restr_sublis [in tactics]
RESTR_rev [in tactics]
RESTR_swapls [in axioms]
RESTR_swap [in axioms]
RESTR_dropone [in axioms]
RESTR_dropls [in axioms]
RESTR_proj [in axioms]
re_cong [in morphisms]
rs_cong [in morphisms]
S
shuffle1 [in foo_axioms]shuffle2 [in foo_axioms]
shuffle3 [in foo_axioms]
shuffle4 [in foo_axioms]
shuffle5 [in foo_axioms]
shuffle6 [in foo_axioms]
shufl_cong [in morphisms]
sign_cong [in morphisms]
split_eqm [in prop1]
split_fresh [in prop1]
substbl_msg_cong [in morphisms]
substbl_bl_cong [in morphisms]
substmsg_msg_cong [in morphisms]
substmsg_Bool_cong [in morphisms]
swapElseBranches [in prop1]
SYM [in axioms]
T
to_cong [in morphisms]TRANS [in axioms]
U
ubEql [in foo_axioms]ubNotUndefined [in foo_axioms]
ubNotUndefined_ext [in prop1]
UFCMA [in axioms]
unblind_cong [in morphisms]
V
ver_cong [in morphisms]vote_len_eql [in prop1]
vote_len_reg [in voteprivacy]
V0_cong [in morphisms]
V1_cong [in morphisms]
Lemma Index
A
andB_TRue_iff [in andbprops]andB_TRue_intro [in andbprops]
andB_assoc1 [in andbprops]
andB_comm1 [in andbprops]
andB_notb_r [in andbprops]
andB_TRue_l [in andbprops]
andB_TRue_r [in andbprops]
andB_diag [in andbprops]
andB_FAlse_l [in andbprops]
andB_FAlse_r [in andbprops]
andB_FAlse_intro2 [in andbprops]
andB_FAlse_intro1 [in andbprops]
and_notB_l [in andbprops]
and_notB_r [in andbprops]
B
b1_notb2 [in andbprops]E
EQb_trans [in morphisms]EQb_ref [in morphisms]
EQb_sym [in morphisms]
EQI_trans [in morphisms]
EQI_sym [in morphisms]
EQI_ref [in morphisms]
eqlistm_ind' [in morphisms]
eqmeql [in prop1]
EQm_trans [in morphisms]
EQm_sym [in morphisms]
EQm_ref [in morphisms]
EQos_trans [in morphisms]
EQos_ref [in morphisms]
EQos_sym [in morphisms]
F
frame1_ind [in voteprivacy]frame2_ind [in voteprivacy]
I
IFIDEMP_B [in andbprops]IFMORPH_B2 [in andbprops]
IFMORPH_B1 [in andbprops]
IFTF [in prop1]
IFTFb [in prop1]
N
notb_FAlse_iff [in andbprops]notB_TRue_iff [in andbprops]
notB_involutive [in andbprops]
P
porp [in prop1]T
true_ident [in prop1]Constructor Index
E
eqb1 [in morphisms]eqconm [in morphisms]
eqconos [in morphisms]
eqm1 [in morphisms]
eqnm [in morphisms]
eqnos [in morphisms]
Inductive Index
E
EQlm [in morphisms]EQos [in morphisms]
EQosl [in morphisms]
Instance Index
B
Bol_Equ_Equiv [in morphisms]E
EQI_Equiv [in morphisms]EQm_Equiv [in morphisms]
L
lm_Eqlm_Equiv [in morphisms]M
ml_Equ_Equiv [in morphisms]O
osl_Equ_Equiv [in morphisms]os_Equ_Equiv [in morphisms]
Section Index
A
andb_props [in andbprops]aux_axioms [in axioms]
C
core_axioms.ifbranch [in axioms]core_axioms.restr [in axioms]
core_axioms.funapp [in axioms]
core_axioms [in axioms]
D
ds_axioms [in axioms]E
eqtheory [in axioms]F
foo_axioms [in foo_axioms]P
prop [in prop1]S
subtrm' [in tactics]Definition Index
A
acc [in voting]acc1 [in voting]
acc2 [in voting]
Avote [in voting]
B
b [in voteprivacy]bcheck [in voting]
beqnat [in tactics]
beqnat_assns [in tactics]
bk [in voting]
Bvote [in voting]
C
c [in voteprivacy]checkostmylis [in tactics]
checksublis [in tactics]
checksublis' [in tactics]
D
d [in voting]dist [in voting]
distbb [in voting]
dist1 [in voting]
dist2 [in voting]
E
e [in voting]eltPos' [in tactics]
EQb [in morphisms]
EQm [in morphisms]
EQml [in morphisms]
e1 [in voting]
F
fintrm [in voting]I
isin [in voting]K
k [in foo_axioms]k0 [in voteprivacy]
k1 [in voteprivacy]
L
label [in voting]len_mylist [in tactics]
M
mapsubtrmls [in tactics]mchecks [in voting]
O
occurNlist [in axioms]P
p [in voting]pchecks [in voting]
phi0 [in voteprivacy]
phi1 [in voteprivacy]
phi2 [in voteprivacy]
phi3 [in voting]
phi4 [in voting]
phi5 [in voting]
phi6 [in voting]
phi7 [in voting]
phi8 [in voting]
pk [in voteprivacy]
R
r [in axioms]r [in foo_axioms]
rb0 [in voteprivacy]
rb1 [in voteprivacy]
rs0 [in voteprivacy]
rs1 [in voteprivacy]
S
s [in voteprivacy]se [in voting]
ssk [in voteprivacy]
ssk0 [in voteprivacy]
ssk1 [in voteprivacy]
strm [in voting]
sublisIndcs [in tactics]
sublisIndcs' [in tactics]
subtrmls_mylis'' [in tactics]
subtrmls_os'' [in tactics]
subtrmls_msg'' [in tactics]
subtrmls_bol'' [in tactics]
T
tau [in voting]theta [in voteprivacy]
theta21 [in voting]
theta23 [in voting]
topsybol_beq [in tactics]
topsymsg_beq [in tactics]
topsyos_beq [in tactics]
tr [in voteprivacy]
t1 [in voteprivacy]
t2 [in voteprivacy]
t3 [in voting]
t4 [in voting]
t4s [in voting]
t4ss [in voting]
t47 [in voting]
t48 [in voting]
t5 [in voting]
t61 [in voting]
t61s [in voting]
t61ss [in voting]
t62 [in voting]
t62s [in voting]
t62ss [in voting]
t71 [in voting]
t71s [in voting]
t72 [in voting]
t72s [in voting]
U
unforgb [in axioms]V
v [in voteprivacy]vcheck [in voteprivacy]
X
x1 [in voteprivacy]x2ft [in voteprivacy]
x2t [in voteprivacy]
x3ftt [in voting]
x3tt [in voting]
x4fttt [in voting]
x4ttt [in voting]
x5ft [in voting]
x5t [in voting]
x6ft [in voting]
x6t [in voting]
x7ft [in voting]
x7t [in voting]
x8ft [in voting]
x8t [in voting]
| Global Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (427 entries) |
| Notation Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (8 entries) |
| Variable Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (1 entry) |
| Library Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (41 entries) |
| Axiom Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (199 entries) |
| Lemma Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (41 entries) |
| Constructor Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (6 entries) |
| Inductive Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (3 entries) |
| Instance Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (7 entries) |
| Section Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (11 entries) |
| Definition Index | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | _ | other | (110 entries) |
This page has been generated by coqdoc


We encourage our members to contact us directly if they have any questions or problems that they would like us to help them with. To send a message from here, please provide the following information:


GOVERNMENT OF THE DISTRICT OF COLUMBIA OFFICE OF THE DEPUTY MAYOR FOR EDUCATION Open Government Report 2014 To institutionalize a culture of transparent and open government, accountability, and to expand opportunities for resident participation and collaboration, this Report describes how the Office of the Deputy Mayor for Education (DME) has and will continue to develop and enhance transparency, public participation, and collaboration. In accordance with Mayor’s Order 2014-170, this report addresses the following topics: 1) Transparency DME’s transparency efforts include the following: DME holds numerous public meetings, hearings and workshops in the community at which information and data is shared with the public including: o the Student Assignment and School Boundaries Review Process o disposition and reuse of excess DC Public Schools o DC Education Adequacy Study o DC Common Lottery (My School DC) We routinely post materials, summaries and feedback from public meetings on our website. Information is also disseminated through press releases, radio, press and digital interviews, stories and advertising. In December, DME will post a copy of the annual supplement to the Master Facilities Plan on our website. The agency meets its obligations pursuant to the District’s Freedom of Information Act and maintains an Open Government and FOIA page on its website. The Deputy Mayor co-chairs the Truancy Taskforce in compliance with the Open Meetings Act. DME is working closely with the Office of the City Administrator (OCA) and the Office of the Chief Technology Officer (OCTO) to identify a significant number of datasets that OCA and OCTO expect to publish online later this year. If no additional datasets from DME are selected to be included in this 2014 release, we will continue to work with OCA and OCTO to identify datasets appropriate to publish in 2015. In the future, requirements for open data reporting will be provided by the Chief Data Officer. 1 2) Public Engagement and Participation In addition to the methods outlined above, DME’s efforts to encourage public participation in agency decision making have included: Creating and using a stakeholder distribution list to provide updates on office projects and meetings. The public is invited to join the office’s distribution list. (Information on upcoming public meetings is also posted on our website and distributed through a number of partner agency and stakeholder distribution lists.) Attending meetings held by community and stakeholder groups. One-on-one meetings with the Deputy Mayor. These public engagement opportunities are outlined on the office website: DME solicits written feedback from community members in the form of surveys and questionnaires on various projects (including the boundaries review process and the school reuse process) in addition to convening targeted focus groups to gather information and feedback. DME participates in the annual public hearing on the budget for public schools. Testimony from the hearing is submitted to the DC Council. 3) Collaboration DME leads, hosts, and participates in a number of collaborative efforts with DC agencies, non-profits and the public including: Co-chairing the Truancy Task Force, and spearheading the Graduation Pathways Project and the Youth Re-Engagement Center Raise DC DC Common Lottery (My School DC) Public Facilities Planning including School Reuse and the Master Facilities Plan Student Assignment and Boundaries Review Process 2


Learn a New Photography Trick or Two
Time to do some photography training, this should be a good one.via Lifehacker by Jason Fitzpatrick on 3/22/10
If you loved browsing the archives of National Geographic when they opened up their vaults last November and found yourself wanting to take your own impressive nature shots, you’ll definitely want to check out the BBC Photo Masterclasses. MoreÂ Â»


Waveform, Spectrogram & Pitch
Version 1.2
© 2016 Mark Huckvale
University College London
www.speechandhearing.net
August 2016


Acropolis
Game Info
“No man or woman born, coward or brave, can shun his destiny.”
― Homer, The Iliad
Setup /
Deploy
/
Attack
/
Fortify
ALWAYS CONFIRM BEFORE ADVANCING TO NEXT PHASE
Roll Dice


project.Rd
Project polytope fit and data in low dimentions (PCA)
project(arc_data, data, n_dim = 3, proj_matrix = NULL)
| arc_data | objects of class "pch_fit", "b_pch_fit", "k_pch_fit" storing the position of archetypes and other data produced by |
|---|---|
| data | matrix of data in which archetypes/polytope were found, dim(variables/dimentions, examples) |
| n_dim | number of principal component dimensions |
| proj_matrix | crossprod(proj_matrix, data) projects data/archetypes into principal component space |
# Random data that fits into the triangle set.seed(4355) arc_data = generate_arc(arc_coord = list(c(5, 0), c(-10, 15), c(-30, -20)), mean = 0, sd = 1) data = generate_data(arc_data$XC, N_examples = 1e4, jiiter = 0.04, size = 0.9)


aima-swift
Houston, we have a vacuum cleaner.
In the spirit of aimacode, this project aims toward a Swift implementation of algorithms from Russell and Norvig’s Artificial Intelligence - A Modern Approach 3rd Edition.
Getting Started
The project uses Xcode 10 and Swift 4.2 which are Beta at time of writing. You can download Xcode Beta
releases from this page. The download unzips into
Xcode-beta.app
and includes the newer Swift
in its toolchain. In order to activate newer Swift
everywhere, either use xcode-select
or run Preferences > Locations from the Xcode-beta
IDE and select it as the location for Command Line Tools.
Then Swift
is magically v4.2 everywhere.
To download the repository:
git clone https://github.com/iDave2/aima-swift.git
To more easily find what Xcode builds, try File > Project Settings and place DerivedData relative to your
project (i.e., in its root). If you cloned the repository to, say, ~/russell-norvig
then an alias like this,
alias swift="swift -F ~/russell-norvig/DerivedData/AImaKit/Build/Products/Debug"
tells Swift where to find the AImaKit framework and lets you easily run tests from a command line. For example,
$ cat test.swift
import AImaKit
typealias VW = VacuumWorld
let agent = VW.ReflexAgent() // Create an agent.
let stuff = Set<EnvironmentObject>([VW.Dirt()]) // Create one dirt.
let percept = VW.AgentPercept(location: VW.left, objects: stuff) // One dirt?
let action = agent.execute(percept) // Give me one dirt, Vasili.
print("Agent sees \(percept), does \"\(action).\"")
Additional unit tests are available in Xcode target AImaKitTests
.
GitHub Pages has additional documentation.
Happy Swifting!


@* * Copyright 2021 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import uk.gov.hmrc.cbcrfrontend.config.FrontendAppConfig @import uk.gov.hmrc.cbcrfrontend.model.ReportingEntityData @import uk.gov.hmrc.cbcrfrontend.views.html._ @this(mainTemplate: main_template) @(reportingEntity: ReportingEntityData)(implicit request: Request[_], messages: Messages, config:FrontendAppConfig) @mainTemplate(title = Messages("")) {
| cbcReportsDRI | @for(cbcReports <- reportingEntity.cbcReportsDRI.toList) { @{cbcReports} } |
|---|---|
| additionalInfoDRI | @for(addintonalInfo <- reportingEntity.additionalInfoDRI) { @{addintonalInfo} } |
| reportingEntityDRI | @{reportingEntity.reportingEntityDRI} |
| tin | @{reportingEntity.tin} |
| ultimateParentEntity | @{reportingEntity.ultimateParentEntity} |
| reportingRole | @{reportingEntity.reportingRole} |
| creationDate | @{reportingEntity.creationDate} |
| reportingPeriod | @{reportingEntity.reportingPeriod} |


Welcome to History Today! Your goal is to figure out, based on each image of a historic location, where that place actually is... and get there! Once you arrive, you can make sure you're right by pressing "I'm Here" on the card. If correct, you get points, and are one step closer to beating the game. Good luck!


Battle is no different than a game of Chess. Like chess, my first move has already decided your fate.
The Chessmaster tactically leads his allies to victory through unparalleled teamwork and camaraderie. Always able to imagine not only the battlefield, but the mindsets of enemy and ally alike, the Chessmaster is able to guide the flow of battle in whatever way he sees fit.
Class Traits
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| Aschente | Field |
During combat, you may place an 8x8 Local Field Effect that includes you within the effect. This is your Board. All of your Actions that have Ranged 3 now have Ranged Board, which includes all squares within the Board and no squares outside of it. You are a King and may also designate a Foe on the board as a King. Kings cannot leave the Board. You may cancel this effect as a Slow Action. Slow + Slow to re-place the board. If you have multiple abilities which designate Kings, you must designate the same Foe for all of them. | ||||||
| Inaugurate | Field |
At the start of Combat, you gain 1 Queen, 2 Knights, 2 Bishops, 2 Rooks, and 8 Pawns as available designations. At any point during combat, you may designate Other Heroes as a piece and the designation lasts until the end of Combat and cannot be changed. Class Actions that list Pieces in the Target can only be used on those Pieces but gain their Inaugurate effect. Any action may be used on a Pawn without the Inaugurate effect. | ||||||
| King's Orders | Field |
At the start of each Other Hero’s turn, the Chessmaster may suggest an action for that Hero to take. That Hero gains a +/- 1 to a single roll or +1 square of movement for the next action they take this turn which follows the Chessmaster’s suggestion. |
Class Actions
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| Pawn's Might | Exploit |
3 |
Target Hero may make a Basic Melee Attack with +2 A to the CAP Check. Delayable. | |||||
| Bishop's Sight | Exploit |
3 |
Target Hero may make a Basic Ranged Attack with a +2 to Range. Delayable. | |||||
| Fortify | Exploit |
3 |
Fortify may not be used if you have taken a Move Action this turn. +3 Toughness and you cannot take a Move Action until your next Turn. Inaugurate: +1 Toughness. Sust. Effect: Repeat Effect. | |||||
| En Passant | Exploit |
3 |
Trig. Cond.: If a Foe moves adjacent to Target Hero, Trig. Effect: -2 A to Target Hero's CAP Check. Target Hero makes a Basic Melee Attack. Inaugurate: There is no penalty to A. |
|||||
| Empower | Exploit |
3 |
Empower may not be used if you have taken a Move Action this turn. +1 Damage OR Healing Die to Target Hero's next Action and you cannot take a Move Action until your next Turn. Once per Turn. Inaugurate: This may be used twice per Turn but the second use may not be on a Pawn. | |||||
| Mind Games | Exploit |
3 |
Trig. Cond.: If a Hero uses a Move or Shift action, Trig. Effect: You may move the Target Foe 1 square. |
|||||
| E1 to E3 | Exploit |
Amp. Effect: +1 Shift movement. | ||||||
| My Turn | Exploit |
3 |
All Target Heroes may make a Shift Action. Amp Effect: Expend an additional Fast Action to allow 1 Target Hero to make a Basic Melee Attack after their Shift Action. |
Class Tide-Turners
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| Promotion | Exploit |
3 |
Target Hero may select 2 Class Actions from another Hero and use those actions as if they had them until the end of the encounter. Inaugurate: Gain 1 additional Class Action and the Chessmaster may change the Target Hero’s designation to any besides King. | |||||
| Castling | Exploit |
3 |
Trig. Cond.: If you are the Target of a Foe's Action, Trig. Effect: Cancel that Action. Swap positions with Target Hero. Target Hero gains +4 Toughness until the end of their next Turn. Inaugurate: +4 Resistance in addition. |
|||||
| Predict the Enemy | Exploit |
3 |
Predict The Enemy may not be used if you have taken a Move Action this turn. At the beginning of your next Turn, you may move each Target Combatant to any other location within Range. Target Combatants are determined by who is in Range at the beginning of the Turn this activates. You cannot take a Move Action until your next Turn. |
Class Traits
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| Embody Piece | Exploit |
When using an ability which lists a piece in its Target, you may grant the Target an additional effect based on the piece.
Pawn: +2 A on next CAP check. Bishop: +2 Range on next Action. Rook: +2 Toughness for 1 Round. Knight: +1 Damage Dice next Damage-dealing Action. Queen: Advantage on next roll. |
||||||
| Perfect Timing | When you use an Action with the Delayable tag, the Chessmaster may allow the Target to choose when the ability is used instead of being used immediately. The Target may use the delayed Action on their Turn as a Free Action. A Hero may only have one Delayed Action at a time. |
Class Actions
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| Rook's Strength | Exploit |
3 |
Target Hero may make a Basic Melee Attack which pushes the Foe 3 squares directly away from the Target Hero. Delayable. | |||||
| Lance's Charge | Exploit |
3 |
Target Hero may move up to 5 squares in a straight line and make a Basic Melee Attack with +2x[number of squares moved] extra damage. Delayable. | |||||
| Shifting Strike | Exploit |
Amp. Effect: You may make a Basic Melee Attack after this Shift Action. | ||||||
| Tactical Move | Exploit |
Amp. Effect: You allow another Hero within Range 3 (or Board) to make an immediate Shift Action. | ||||||
| Sword Eruption | Spell |
3 |
Sword Eruption may not be used if you have taken a Move Action this turn. [Tier]d6 PIERCING Damage to all Foes in Range 1 of Target Hero and you cannot use a Move Action until your next Turn. Inaugurate: Damages all Foes in Range 2 of Target Hero instead. Delayable. | |||||
| Divine Lighting | Spell |
3 |
Divine Lightning may not be used if you have taken a Move Action this Turn. Target Hero deals [Tier+1]d6 PIERCING Damage to all Foes in a straight line up to Range 5. Each Foe hit reduces the damage that the next Foe receives by the amount that they received. You cannot take a Move Action until your next Turn. Inaugurate: Deals an additional Damage Die. Delayable. | |||||
| Binding Chains | Spell |
3 |
Binding Chains may not be used if you have taken a Move Action this turn. All Foes within Range 1 of the Target Hero may not move from their square on their next Turn and you cannot take a Move Action until your next Turn. Inaugurate: The range is now Range 2 Delayable. | |||||
| My Rules | Spell |
3 |
Foes can not leave the Range of this Action. Sust. Effect: Repeat Effect. |
Class Tide-Turners
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| Shifting Tides | Exploit |
3 |
Target Hero does not need to spend a Tide-Turner Charge on their next Tide-Turner. | |||||
| New Frame of Mind | Exploit |
3 |
New Frame of Mind may not be used if you have taken a Move Action this turn. Target Foes has 4 vulnerability. You cannot take a Move Action until your next Turn. Sust. Effect: Repeat Effect. | |||||
| Desperado | Exploit |
3 |
Trig. cond: When the Target Hero takes damage,
Trig. Effect: If this Damage would cause the Target Hero to become FALLEN, the Target Hero may immediately take a full turn before applying the Damage. Otherwise, the Target Hero may immediately make two Basic Weapon Attacks. |
Class Traits
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| King's Game | Field |
You are a King and may also designate a Foe on the board as a King at the start of the Combat Encounter. Kings may not Target Each other with Damage dealing abilities and may not move adjacent to each other. You may cancel this effect as a Slow Action. If you have multiple abilities which designate Kings, you must designate the same Foe for all of them. | ||||||
| Shogi Board | At the start of Combat, you may place a 9x9 Local Field Effect. This is your Board. All of your Actions that have Ranged 3 now have Ranged Board, which includes all squares within the Board and no squares outside of it. You may cancel this effect as a Slow Action. If you have Aschente, this upgrades Aschente’s Board to 9x9. |
Class Actions
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| Knight's Spear | Exploit |
3 |
Target Hero may make a Basic Melee Attack with +2 Range. Delayable. | |||||
| Silver General's Reposition | Exploit |
3 |
Target Hero may make a Basic Weapon Attack and then make an immediate Shift Action. Delayable. | |||||
| Like an Open Book | Exploit |
3 |
Target Foe rolls its d6 to determine its Action Chain for its next Turn immediately and the Chessmaster learns which Actions it will take. If playing with a Storyteller, they must tell the Chessmaster which Actions the Foe will take and must follow through with those Actions on the Foe’s next Turn. | |||||
| Breakthrough | Exploit |
Target Hero gains the Inaugurate effect of the Target Action if they do not already receive it. If you have Inaugurate, this can only be used on Actions that Target a Pawn. | ||||||
| Bodyguard | Exploit |
3 |
Bodyguard may not be used if you have taken a Move Action this Turn. Heroes adjacent to the Target have Advantage on Dodge rolls and you cannot take a Move Action until your next Turn. Inaugurate: The Target Hero also have Advantage on Dodge rolls. Sust. Effect: Repeat Effect | |||||
| Crushing Presence | Spell |
3 |
Crushing Presence may not be used if you have taken a Move Action this Turn. All Foes within Range 3 of Target Hero are knocked PRONE and you cannot take a Move Action until your next Turn. Inaugurate: Affected Foes also gain the DAZE condition for 1 Round. Delayable. | |||||
| Opportune Strike | Exploit |
3 |
Opportune Strike may not be used if you have taken a Move Action this Turn. Target Hero makes a Basic Melee Attack with AUTO-HIT and you cannot take a Move Action until your next Turn. Inaugurate: Ignore Target's Toughness. Delayable. | |||||
| My Game | Exploit |
3 |
When two Heroes are adjacent, they count as flanking. Sust. Effect: Repeat Effect. |
Class Tide-Turners
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| Drop | Spell |
3 |
Target Foe gains [Tier+1]x10 HP (not exceeding their max HP) and will fight for the Chessmaster. All abilities which Target this Foe gain the AUTO-HIT property. At the beginning of the Chessmaster’s turn, this Foe moves up to 5 squares to the nearest Foe and makes a Basic Melee Attack using the Chessmaster’s CAP and dealing [Tier]d10 Damage. At the end of the Combat Encounter, this Foe becomes FALLEN. | |||||
| Fear the King | Exploit |
You gain +2 Toughness and Resistance and gain +1 Damage Dice on Melee Attack Actions. Sust. Effect: Repeat Effect. | ||||||
| Clever Laziness | Exploit |
3 |
All Target Heroes gain +2 A. If you have Inaugurate, Target Heroes instead gain a bonus based on their designation. Sust. Effect: Repeat Effect.
Pawn: +2 A. Bishop: +2 Range. Rook: +2 Toughness. Knight: +1 Damage Dice on Damage-dealing Actions. Queen: Advantage on a roll once per Round. |
Class Traits
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| Check | Field |
At the start of Combat, declare 1 Foe and an additional Foe for each Hero that chooses to be affected by this ability. When targeted combatants are Flanked, they gain FRAGILITY. Kings are always affected by this ability and if a King is Flanked, all attacks against them are AUTO-HIT in addition. | ||||||
| Strength in Numbers | When you use an Action on a Rook, Bishop, Knight, or Queen, it may also affect all other pieces of the same type. Once per Round. |
Class Actions
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| Queen's Elegance | Exploit |
3 |
Target Hero may make a Basic Weapon Attack with advantage on the CAP Check. Delayable. | |||||
| Gold General's Spite | Exploit |
3 |
Target Hero may make a Basic Weapon Attack with +2 Damage Dice. Delayable. | |||||
| Unlock Potential | Exploit |
3 |
One of the Target Hero's Special Action Limits (Amplify, Sustain, Trigger) is increased by 1. | |||||
| Steel Resolve | Exploit |
3 |
Trig. Cond.: When Target Hero is hit with a Damage-dealing Action,
Trig. Effect: Target Hero gains +4 Toughness. If the Target Hero takes no Damage from the triggering Action, the Target Hero may make a Basic Weapon Attack. Inaugurate: + 2 Toughness |
|||||
| Healing Light | Spell |
3 |
Healing Light may not be used if you have taken a Move Action this Turn. Target Hero may heal themselves or another Hero within Range 3 for [Tier]x5 HP and you may not Take a Move Action until your next Turn. Inaugurate: +5 HP healed. Delayable. | |||||
| Dedication | Exploit |
3 |
Trig. Cond.: When Target Hero causes a Foe to become Fallen,
Trig. Effect: Target Hero may make a Move Action towards another Foe. Inaugurate: +2 Speed for this action. |
|||||
| Death Do Us Part | Exploit |
3 |
Trig. Cond.: When you are the Target of a Foe's Action,
Trig. Effect: The Target Hero may choose to teleport adjacent to the Foe or teleport the Foe Adjacent to the Target Hero. The Target Hero makes a Basic Melee Attack before resolving the triggering Action. Inaugurate: +2A. |
|||||
| My World | Exploit |
Field |
At the end of each Foe's Turn, if they are not within Range 3 (or Board) they are moved 1 Square closer to your Range (or Board). Sust. Effect: Repeat Effect. |
Class Tide-Turners
| Name | Effect | |||||||
|---|---|---|---|---|---|---|---|---|
| Checkmate | Exploit |
3 |
Enemy King becomes FALLEN if it is a Grunt. For each Other Hero adjacent to the Enemy King, this ability increases the tier of Foe which it can affect. | |||||
| Carpe Diem | Exploit |
Carpe Diem may not be used if you have taken a Move Action this Turn. Target Foes skip their next Turn and you may not take a Move action this Turn. | ||||||
| Commanding Prowess | Exploit |
3 |
Commanding Prowess may not be used if you have taken a Move Action this Turn. Target Foes are PARALYZED and you may not take a Move Action this Turn. |


Innovative Programmer striving to make the world a more unified and connected place. Experienced Software Engineer with a demonstrated history of working in the information technology and services industry. Skilled in Python, AWS, Core Java, Scala, Kafka streaming, React.
SKILLS PROJECTS CONTACT


FacialPay New User Sign-up
Next Gen Banking.
Moving towards
Cash
Card
Face based society!
Customer Name
Username
Password
Starting Balance
* Please look at the camera


|
Perl Weekly
Issue #38 - 2012-04-16 - Over 3000 subscribers!
latest | archive | by Gabor Szabo
|
|
Hi and welcome to the new subscribers!
It seems this was a very busy week. Lots of posts. Way too many to include all of them here.
We have also passed the 3,000 subscribers. I wrote about this and the post was submitted to Hacker News. This brought quite a number of new subscribers. For more details check the 'self promotion' section below.
Now to the interesting stuff:
|
|
|
Announcements
|
A pastebin with almost no user interface
Mike Doherty wrote WWW::Hashbang::Pastebin, a simple pastebin written in Dancer. I guess it could be nice to set it up within a company and start using it for showing code examples via the network.
|
|
Foswiki 1.1.5 released
Michael Daum announced the new release of the Perl based wiki. This includes both security fixes and other improvements.
|
|
|
|
|
|
|
|
Articles
|
Defending Against Its Dynamic Scope
chromatic writes about a nasty trap that one can fall in when using $_ in a construct that calls some other code that might change $_. It is especially a problem in map and grep where you have to use $_.
|
|
|
|
Mojolicious Boilerplate Evolution
Tudor Constantin tells us the story behind the evolution of the Mojolicious Boilerplate. Some features that were added and lots of plans he has for the project.
|
|
|
|
Discussion
|
|
|
Testing
|
|
|
Learning Perl with Testing
Instead of Test Driven Development, Nitish Bezzala suggests Test Driven Learning. I think this can be a good idea though one needs to think how to introduce it and how to make sure the test framework does not hide problems or introduces new ones.
|
|
Mock Objects Despoil Your Tests
While I agree with chromatic that too much mocking in tests is not healthy I am really not sure where does he get the idea that mocking is overused. The companies I visit never do mocking. OK, they usually don't do any testing and that's why they invite me and the only way to get some test up there is to mock half the universe. Or at least the external APIs. In any case, it would be interesting to check the level of mocking within CPAN.
|
|
|
|
Perl QA Hackathon
A late memoire from the Brazilian player called Breno G. de Oliveira (garu).
|
|
Code
|
|
|
|
|
Perl - How to work offline?
Geistteufel sets up his environment to be able to work offline. Including having access to CPAN while on the road using Mini CPAN.
|
|
|
|
Fun
|
|
|
|
|
Perl 6
|
|
|
|
|
|
|
Training
|
And now Lisbon too...
In addition to London, Oslo, and Zurich, Damian Conway will visit Lisbon too. Be prepared!
|
|
The self promotion section
|
|
|
Events
|
|
|
|
|
YAPC::NA
June 13-15, 2012, Madison, Wisconsin, USA
|
|
|
|
You know, you could get the Perl Weekly right in your mailbox. Every Week. Free of charge!
|