@(title: String)(content: Html)(implicit request: play.api.mvc.RequestHeader)
@* See see: paulirish.com/2008/conditional-stylesheets-vs-css-hacks-answer-neither/ on usage of these classes *@
@* If possible use .htaccess and remove these lines to avoid edge case issues. More info: h5bp.com/b/378 *@
@* Supresses IE6 image toolbar *@
@* Page details *@
@* Meta tag to ensure devices display responsive pages properly *@
@title
@* Both bootstrap.min.css and responsive.min.css are merged together to reduce css requests *@
@* This script contains at the bottom some extra code unrelated to modernizr *@
@* Prompt IE 6 users to upgrade or install Chrome Frame. chromium.org/developers/how-tos/chrome-frame-getting-started *@
@content
@* We load scripts asynchronously except the JQuery one, to avoid clashes with dependencies *@
@* Matchmedia is an external polyfill to allow media query testing in js if not supported by browser *@
@* Picturefill allows displaying of responsive images using media queries *@


Trait that provides some basic syntax sugar for EasyMock.
Class that wraps and manages the lifecycle of a single org.jmock.Mockery
context object,
provides some basic syntax sugar for using JMock
in Scala.
Trait that will pass a new JMockCycle
into any test that needs one.
Subclass of org.jmock.Expectations
that provides withArg
alternatives to the with
methods defined in its superclass.
Trait that provides some basic syntax sugar for Mockito.
Companion object that facilitates the importing of EasyMockSugar
members as
an alternative to mixing it in.
Companion object that facilitates the importing of MockitoSugar
members as
an alternative to mixing it in.


| (++) [Pretty] | Concatenates two documents. |
A | |
| addAttribute [Cil] | Add an attribute. |
| addAttributes [Cil] | Add a list of attributes. |
| addOffset [Cil] |
|
| addOffsetLval [Cil] | Add an offset at the end of an lvalue. |
| additiveLevel [Cil] | |
| addrOfLevel [Cil] | |
| align [Pretty] | Mark the current column as the current indentation level. |
| alignOf_int [Cil] | The minimum alignment (in bytes) for a type. |
| allStmts [Cfg] | Return all statements in a file - valid after computeFileCfg only |
| append [Clist] | Append two clists |
| argsToList [Cil] | Obtain the argument list ([] if None) |
| arrowLevel [Cil] | |
| attributeHash [Cil] | This table contains the mapping of predefined attributes to classes. |
| auto_printer [Pretty] | A function that when used at top-level in a module will direct the pa_prtype module generate automatically the printing functions for a type |
B | |
| bitsOffset [Cil] | Give a type of a base and an offset, returns the number of bits from the base address and the width (also expressed in bits) for the subobject denoted by the offset. |
| bitsSizeOf [Cil] | The size of a type, in bits. |
| bitwiseLevel [Cil] | |
| blueEscStr [Errormsg] | |
| break [Pretty] | A document that consists of either a space or a line break. |
| bug [Errormsg] | Similar to |
| bug [Cil] | Like |
| builtinFunctions [Cil] | A list of the built-in functions for the current compiler (GCC or
MSVC, depending on |
| builtinLoc [Cil] | This is used as the location of the prototypes of builtin functions. |
| bytesSizeOfInt [Cil] | The size in bytes of the given int kind. |
C | |
| cExp [Formatcil] | Constructs an expression based on the program and the list of arguments. |
| cInstr [Formatcil] | Constructs an instruction based on the program and the list of arguments. |
| cLval [Formatcil] | Constructs an lval based on the program and the list of arguments. |
| cStmt [Formatcil] | |
| cStmts [Formatcil] | Constructs a list of statements |
| cType [Formatcil] | Constructs a type based on the program and the list of arguments. |
| caseRangeFold [Cil] | Fold every |
| cfgFun [Cfg] | Compute a control flow graph for fd. |
| charConstPtrType [Cil] | char const * |
| charConstToInt [Cil] | Given the character c in a (CChr c), sign-extend it to 32 bits. |
| charPtrType [Cil] | char * |
| charType [Cil] | char |
| char_is_unsigned [Cil] | Whether "char" is unsigned. |
| checkBeforeAppend [Clist] | A useful check to assert before an append. |
| children [Dominators] | Return a list of statements dominated by the argument |
| chr [Pretty] | A document that prints a character. |
| cilVersion [Cil] | These are the CIL version numbers. |
| cilVersionMajor [Cil] | |
| cilVersionMinor [Cil] | |
| cilVersionRevision [Cil] | |
| cilint_to_int [Cil] | Convert a cilint int to an OCaml int, or raise an exception if that can't be done. |
| clearCFGinfo [Cfg] | clear the sid, succs, and preds fields of each statment in a function |
| clearFileCFG [Cfg] | clear the sid, succs, and preds fields of each statement. |
| colorFlag [Errormsg] | Set to true if you want error and warning messages to be colored |
| combinePredecessors [Dataflow.ForwardsTransfer] | Take some old data for the start of a statement, and some new data for the same point. |
| combineStmtStartData [Dataflow.BackwardsTransfer] | When the analysis reaches the start of a block, combine the old data with the one we have just computed. |
| combineSuccessors [Dataflow.BackwardsTransfer] | Take the data from two successors and combine it |
| commonIntKind [Cil] | Return the common integer kind of the two integer arguments, as defined in ISO C <IP_ADDRESS> ("Usual arithmetic conversions") |
| compFullName [Cil] | Get the full name of a comp |
| compactStmts [Cil] | Try to compress statements so as to get maximal basic blocks. |
| comparativeLevel [Cil] | |
| compareLoc [Cil] | Comparison function for locations. |
| compute [Dataflow.BackwardsDataFlow] | Fill in the T.stmtStartData, given a number of initial statements to start from (the sinks for the backwards data flow). |
| compute [Dataflow.ForwardsDataFlow] | Fill in the T.stmtStartData, given a number of initial statements to start from. |
| computeCFGInfo [Cil] | Compute the CFG information for all statements in a fundec and return a list of the statements. |
| computeDomTree [Dominators] | returns the IDoms and a map from statement ids to the set of statements that are dominated |
| computeFileCFG [Cfg] | Compute the CFG for an entire file, by calling cfgFun on each function. |
| computeFirstPredecessor [Dataflow.ForwardsTransfer] | Give the first value for a predecessors, compute the value to be set for the block |
| computeIDom [Dominators] | Invoke on a code after filling in the CFG info and it computes the immediate dominator information. |
| concat [Pretty] | |
| constFold [Cil] | Do constant folding on an expression. |
| constFoldBinOp [Cil] | Do constant folding on a binary operation. |
| constFoldVisitor [Cil] | A visitor that does constant folding. |
| convertInts [Cil] | |
| copy [Dataflow.ForwardsTransfer] | Make a deep copy of the data |
| copyCompInfo [Cil] | Makes a shallow copy of a |
| copyFunction [Cil] | Create a deep copy of a function. |
| copyVarinfo [Cil] | Make a shallow copy of a |
| countCalls [Stats] | Flag to indicate whether or not to count the number of calls of
to |
| countNewLines [Pretty] | Keep a running count of the taken newlines. |
| currentGlobal [Cil] | A reference to the current global being visited |
| currentLoc [Cil] | A reference to the current location. |
| cyanEscStr [Errormsg] | |
D | |
| dExp [Formatcil] | Deconstructs an expression based on the program. |
| dExp [Cil] | Generate an |
| dGlobal [Cil] | Generate a |
| dInstr [Formatcil] | Deconstructs an instruction based on the program. |
| dInstr [Cil] | Generate an |
| dLval [Formatcil] | Deconstructs an lval based on the program. |
| dType [Formatcil] | Deconstructs a type based on the program. |
| d_attr [Cil] | Pretty-print an attribute using |
| d_attrlist [Cil] | Pretty-print a list of attributes using |
| d_attrparam [Cil] | Pretty-print an argument of an attribute using |
| d_binop [Cil] | Pretty-print a binary operator |
| d_block [Cil] | Pretty-print a block using |
| d_const [Cil] | Pretty-print a constant |
| d_exp [Cil] | Pretty-print an expression using |
| d_fkind [Cil] | Pretty-print a floating-point kind |
| d_formatarg [Cil] | Pretty-prints a format arg |
| d_global [Cil] | Pretty-print the internal representation of a global using
|
| d_hloc [Errormsg] | |
| d_ikind [Cil] | Pretty-print an integer of a given kind |
| d_init [Cil] | Pretty-print an initializer using |
| d_instr [Cil] | Pretty-print an instruction using |
| d_int32 [Pretty] | Print an int32 |
| d_int64 [Pretty] | |
| d_label [Cil] | Pretty-print a label using |
| d_list [Pretty] | sm: Yet another list printer. |
| d_loc [Errormsg] | |
| d_loc [Cil] | Pretty-print a location |
| d_lval [Cil] | Pretty-print an lvalue using |
| d_map [Pretty.MakeMapPrinter] | Format a map, analogous to d_list. |
| d_offset [Cil] | Pretty-print an offset using |
| d_plainexp [Cil] | Pretty-print the internal representation of an expression |
| d_plaininit [Cil] | Pretty-print the internal representation of an integer |
| d_plainlval [Cil] | Pretty-print the internal representation of an lvalue |
| d_plaintype [Cil] | Pretty-print the internal representation of a type |
| d_set [Pretty.MakeSetPrinter] | Format a set, analogous to d_list. |
| d_shortglobal [Cil] | Pretty-print a short description of the global. |
| d_stmt [Cil] | Pretty-print a statement using |
| d_storage [Cil] | Pretty-print storage-class information |
| d_thisloc [Cil] | Pretty-print the |
| d_type [Cil] | Pretty-print a type using |
| d_typsig [Cil] | Print a type signature |
| d_unop [Cil] | Pretty-print a unary operator |
| dd_exp [Cil] | Pretty-print an expression while printing descriptions rather than names of temporaries. |
| dd_lval [Cil] | |
| debug [Dataflow.BackwardsTransfer] | Whether to turn on debugging |
| debug [Dataflow.ForwardsTransfer] | Whether to turn on debugging |
| debugFlag [Errormsg] | If set then print debugging info |
| defaultCilPrinter [Cil] | |
| derefStarLevel [Cil] | |
| descriptiveCilPrinter [Cil] | |
| dn_attr [Cil] | |
| dn_attrlist [Cil] | |
| dn_attrparam [Cil] | |
| dn_exp [Cil] | Versions of the above pretty printers, that don't print #line directives |
| dn_global [Cil] | |
| dn_init [Cil] | |
| dn_instr [Cil] | |
| dn_lval [Cil] | |
| dn_stmt [Cil] | |
| dn_type [Cil] | |
| doGuard [Dataflow.ForwardsTransfer] | Generate the successor to an If statement assuming the given expression is nonzero. |
| doInstr [Dataflow.BackwardsTransfer] | The (backwards) transfer function for an instruction. |
| doInstr [Dataflow.ForwardsTransfer] | The (forwards) transfer function for an instruction. |
| doStmt [Dataflow.BackwardsTransfer] | The (backwards) transfer function for a branch. |
| doStmt [Dataflow.ForwardsTransfer] | The (forwards) transfer function for a statement. |
| docAlphaTable [Alpha] | Split the name in preparation for newAlphaName. |
| docArray [Pretty] | Formats an array. |
| docCList [Clist] | A document for printing a clist (similar to |
| docList [Pretty] | An alternative function for printing a list. |
| docMap [Pretty.MakeMapPrinter] | Format a map, analogous to docList. |
| docOpt [Pretty] | Prints an |
| docSet [Pretty.MakeSetPrinter] | Format a set, analogous to docList. |
| domTreeIter [Dominators] | Iterate over a dominator tree |
| dominates [Dominators] | Check whether one statement dominates another. |
| doubleType [Cil] | double |
| dprintf [Pretty] | This function provides an alternative method for constructing
|
| dropAttribute [Cil] | Remove all attributes with the given name. |
| dropAttributes [Cil] | Remove all attributes with names appearing in the string list. |
| dummyFile [Cil] | A dummy file |
| dummyFunDec [Cil] | A dummy function declaration handy when you need one as a placeholder. |
| dummyInstr [Cil] | A instr to serve as a placeholder |
| dummyStmt [Cil] | A statement consisting of just |
| dumpBlock [Cil] | Dump a block to a file using a given indentation. |
| dumpFile [Cil] | Pretty-print an entire file. |
| dumpGlobal [Cil] | Pretty-print a global. |
| dumpInit [Cil] | Dump an initializer to a file using a given indentation. |
| dumpStmt [Cil] | Dump a statement to a file using a given indentation. |
E | |
| empty [Clist] | The empty clist |
| emptyFunction [Cil] | Make an empty function |
| enable [Feature] | Enable a given feature, by name. |
| enabled [Feature] | Check if a given feature is enabled. |
| endsWith [Cil] | return true if the first is a suffix of the second string |
| envMachine [Cil] | Machine model specified via CIL_MACHINE environment variable |
| eprintf [Pretty] | Like |
| error [Errormsg] | Prints an error message of the form |
| error [Cil] | Like |
| errorLoc [Cil] | Like |
| existsType [Cil] | Scans a type by applying the function on all elements. |
| expToAttrParam [Cil] | Convert an expression into an attrparam, if possible. |
F | |
| f_int32 [Pretty] | |
| f_int64 [Pretty] | |
| fastMode [Pretty] | If set to |
| filterAttributes [Cil] | Retains attributes with the given name |
| filterStmt [Dataflow.BackwardsTransfer] | Whether to put this predecessor block in the worklist. |
| filterStmt [Dataflow.ForwardsTransfer] | Whether to put this statement in the worklist. |
| find [Feature] | Find a feature by name. |
| findNaturalLoops [Dominators] | Compute the start of the natural loops. |
| findOrCreateFunc [Cil] | Find a function or function prototype with the given name in the file. |
| find_stmts [Dataflow] | Returns (all_stmts, sink_stmts), where all_stmts is a list of the statements in a function, and sink_stmts is a list of the return statments (including statements that fall through the end of a void function). |
| finishParsing [Errormsg] | |
| fitsInInt [Cil] | True if the integer fits within the kind's range |
| flattenBeforePrint [Pretty] | Whether to rebalance doc before printing it to avoid stack-overflows |
| floatKindForSize [Cil] | The float kind for a given size. |
| flushOften [Pretty] | If true the it flushes after every print |
| foldGlobals [Cil] | Fold over all globals, including the global initializer |
| foldLeftCompound [Cil] | Fold over the list of initializers in a Compound (not also the nested ones). |
| fold_left [Clist] | A version of fold_left that works on clists |
| forgcc [Cil] | Return the string 's' if we're printing output for gcc, suppres it if we're printing for CIL to parse back in. |
| fprint [Pretty] | Format the document to the given width and emit it to the given channel |
| fprintf [Pretty] | Like |
| fromList [Clist] | Convert an ordinary list to a clist |
| funcExitData [Dataflow.BackwardsTransfer] | The data at function exit. |
G | |
| gccBuiltins [Cil] | |
| getAlphaPrefix [Alpha] | |
| getCompField [Cil] | Return a named fieldinfo in compinfo, or raise Not_found |
| getGlobInit [Cil] | Get the global initializer and create one if it does not already exist. |
| getHPosition [Errormsg] | high-level position |
| getIdom [Dominators] | This is like Inthash.find but gives an error if the information is Not_found |
| getInteger [Cil] | If the given expression is an integer constant or a CastE'd integer constant, return that constant's value. |
| getLocation [Errormsg] | |
| getParenthLevel [Cil] | Parentheses level. |
| getPosition [Errormsg] | |
| get_globalLoc [Cil] | Return the location of a global, or locUnknown |
| get_instrLoc [Cil] | Return the location of an instruction |
| get_stmtLoc [Cil] | Return the location of a statement, or locUnknown |
| gprintf [Pretty] | Like |
| greenEscStr [Errormsg] | |
H | |
| hadErrors [Errormsg] | This is set whenever one of the above error functions are called. |
| hasAttribute [Cil] | True if the named attribute appears in the attribute list. |
I | |
| i64_to_int [Cil] | Convert a 64-bit int to an OCaml int, or raise an exception if that can't be done. |
| increm [Cil] | Increment an expression. |
| indent [Pretty] | Indents the document. |
| indexLevel [Cil] | |
| initCIL [Cil] | Call this function to perform some initialization. |
| insert [Pretty] | A function that is useful with the |
| insertImplicitCasts [Cil] | Do insert implicit casts (default true) |
| intKindForSize [Cil] | The signed integer kind for a given size (unsigned if second argument is true). |
| intKindForValue [Cil] | Return the smallest kind that will hold the integer's value. |
| intPtrType [Cil] | int * |
| intRank [Cil] | Return the integer conversion rank of an integer kind |
| intType [Cil] | int |
| integer [Cil] | Construct an integer of kind IInt. |
| invalidStmt [Cil] | An empty statement. |
| isArithmeticType [Cil] | True if the argument is an arithmetic type (i.e. |
| isArrayType [Cil] | True if the argument is an array type |
| isCompleteType [Cil] | Returns true if this is a complete type. |
| isConstant [Cil] | True if the expression is a compile-time constant |
| isConstantOffset [Cil] | True if the given offset contains only field nanmes or constant indices. |
| isFunctionType [Cil] | True if the argument is a function type |
| isInteger [Cil] | |
| isIntegralType [Cil] | True if the argument is an integral type (i.e. |
| isPointerType [Cil] | True if the argument is a pointer type |
| isScalarType [Cil] | True if the argument is a scalar type |
| isSigned [Cil] | Returns true if and only if the given integer type is signed. |
| isVoidPtrType [Cil] | is the given type "void *"? |
| isVoidType [Cil] | is the given type "void"? |
| isZero [Cil] | True if the given expression is a (possibly cast'ed) integer or character constant with value zero |
| iter [Clist] | A version of iter that works on clists |
| iterGlobals [Cil] | Iterate over all globals, including the global initializer |
K | |
| kindOfSizeOf [Cil] | The integer kind of |
| kinteger [Cil] | Construct an integer of a given kind. |
| kinteger64 [Cil] | Construct an integer of a given kind, using OCaml's int64 type. |
| kintegerCilint [Cil] | Construct an integer of a given kind, from a cilint. |
L | |
| lastTime [Stats] | |
| leftflush [Pretty] | Use after a |
| lenOfArray [Cil] | Call to compute the array length as present in the array type, to an integer. |
| length [Clist] | Find the length of a clist |
| line [Pretty] | A document that consists of a mandatory newline. |
| lineDirectiveStyle [Cil] | How to print line directives |
| lineLength [Cil] | The length used when wrapping output lines. |
| list_registered [Feature] | List registered features. |
| little_endian [Cil] | Whether the machine is little endian. |
| loadBinaryFile [Cil] | Read a |
| locUnknown [Errormsg] | An unknown location for use when you need one but you don't have one |
| locUnknown [Cil] | Represents a location that cannot be determined |
| log [Errormsg] | Print something to |
| logChannel [Errormsg] | A channel for printing log messages |
| logg [Errormsg] | same as |
| longType [Cil] | long |
| lookupTime [Stats] | Return the cumulative time of all calls to |
| lowerConstants [Cil] | Do lower constants (default true) |
| lowerEnumVisitor [Cillower] | Replace enumeration constants with integer constants |
M | |
| makeFormalVar [Cil] | Make a formal variable for a function. |
| makeGlobalVar [Cil] | Make a global variable. |
| makeLocalVar [Cil] | Make a local variable and add it to a function's slocals (only if insert = true, which is the default). |
| makeStaticGlobal [Cil] | Whether to convert local static variables into global static variables |
| makeTempVar [Cil] | Make a temporary variable and add it to a function's slocals. |
| makeVarinfo [Cil] | Make a varinfo. |
| makeZeroInit [Cil] | Make a initializer for zero-ing a data type |
| map [Clist] | Map a function over a clist. |
| mapGlobals [Cil] | Map over all globals, including the global initializer and change things in place |
| mapNoCopy [Cil] | Like map but try not to make a copy of the list |
| mapNoCopyList [Cil] | Like map but each call can return a list. |
| mark [Pretty] | Mark the beginning of a markup section. |
| markup [Pretty] | Prints a document as markup. |
| missingFieldName [Cil] | This is a constant used as the name of an unnamed bitfield. |
| mkAddrOf [Cil] | Make an AddrOf. |
| mkAddrOrStartOf [Cil] | Like mkAddrOf except if the type of lval is an array then it uses StartOf. |
| mkBlock [Cil] | Construct a block with no attributes, given a list of statements |
| mkCast [Cil] | Like |
| mkCastT [Cil] | Construct a cast when having the old type of the expression. |
| mkCilint [Cil] | Construct a cilint from an integer kind and int64 value. |
| mkCompInfo [Cil] | Creates a a (potentially recursive) composite type. |
| mkEmptyStmt [Cil] | Returns an empty statement (of kind |
| mkFor [Cil] | Make a for loop for(start; guard; next) { ... |
| mkForIncr [Cil] | Make a for loop for(i=start; i<past; i += incr) { ... |
| mkMem [Cil] | Make a Mem, while optimizing AddrOf. |
| mkStmt [Cil] | Construct a statement, given its kind. |
| mkStmtOneInstr [Cil] | Construct a statement consisting of just one instruction |
| mkString [Cil] | Make an expression that is a string constant (of pointer type) |
| mkWhile [Cil] | Make a while loop. |
| mone [Cil] | -1 |
| msvcBuiltins [Cil] | |
| msvcMode [Cil] | Whether the pretty printer should print output for the MS VC compiler. |
N | |
| name [Dataflow.BackwardsTransfer] | For debugging purposes, the name of the analysis |
| name [Dataflow.ForwardsTransfer] | For debugging purposes, the name of the analysis |
| newAlphaName [Alpha] | Create a new name based on a given name. |
| newHline [Errormsg] | |
| newVID [Cil] | Generate a new variable ID. |
| new_sid [Cil] | |
| newline [Errormsg] | |
| nil [Pretty] | Constructs an empty document |
| noMemoize [Formatcil] | If set then will not memoize the parsed patterns |
| null [Errormsg] | Do not actually print (i.e. |
| num [Pretty] | A document that prints an integer in decimal form |
| num64 [Pretty] | A document that prints a 64-bit int in decimal form |
O | |
| oldstyleExternInline [Cil] | Set this to true to get old-style handling of gcc's extern inline C extension: old-style: the extern inline definition is used until the actual definition is seen (as long as optimization is enabled) new-style: the extern inline definition is used only if there is no actual definition (as long as optimization is enabled) Note that CIL assumes that optimization is always enabled ;-) |
| one [Cil] | 1 |
P | |
| parseInt [Cil] | Convert a string representing a C integer literal to an expression. |
| parse_error [Errormsg] | |
| partitionAttributes [Cil] | Partition the attributes into classes:name attributes, function type, and type attributes |
| peepHole1 [Cil] | Similar to |
| peepHole2 [Cil] | A peephole optimizer that processes two adjacent instructions and possibly replaces them both. |
| plainCilPrinter [Cil] | |
| popContext [Errormsg] | Removes the last registered context printing function |
| prepareCFG [Cil] | Prepare a function for CFG information computation by
|
| pretty [Dataflow.BackwardsTransfer] | Pretty-print the state |
| pretty [Dataflow.ForwardsTransfer] | Pretty-print the state |
| print [Stats] | Print the current stats preceeded by a message |
| printAttr [Cil] | Print an attribute given a pretty printer |
| printAttrs [Cil] | Print a set of attributes given a pretty printer |
| printBlock [Cil] | Print a block given a pretty printer. |
| printCfgChannel [Cfg] | print control flow graph (in dot form) for fundec to channel |
| printCfgFilename [Cfg] | Print control flow graph (in dot form) for fundec to file |
| printCilAsIs [Cil] | Whether to print the CIL as they are, without trying to be smart and print nicer code. |
| printDepth [Pretty] | Specifies the nesting depth of the |
| printExp [Cil] | Print an expression given a pretty printer |
| printGlobal [Cil] | Print a global given a pretty printer |
| printIndent [Pretty] | If false then does not indent |
| printInit [Cil] | Print an initializer given a pretty printer. |
| printInstr [Cil] | Print an instruction given a pretty printer |
| printLval [Cil] | Print an lvalue given a pretty printer |
| printStmt [Cil] | Print a statement given a pretty printer. |
| printType [Cil] | Print a type given a pretty printer |
| print_CIL_Input [Cil] | Whether we print something that will only be used as input to our own parser. |
| printerForMaincil [Cil] | zra: This is the pretty printer that Maincil will use. |
| printf [Pretty] | Like |
| ptrdiffType [Cil] | An signed integer type that fits pointer difference. |
| purpleEscStr [Errormsg] | |
| pushContext [Errormsg] | Registers a context printing function |
| pushGlobal [Cil] | CIL keeps the types at the beginning of the file and the variables at the end of the file. |
R | |
| readingFromStdin [Errormsg] | Records whether the stdin is open for reading the goal * |
| real [Pretty] | A document that prints a real number |
| redEscStr [Errormsg] | |
| register [Feature] | Register a feature to be used by CIL. |
| registerAlphaName [Alpha] | Register a name with an alpha conversion table to ensure that when later we call newAlphaName we do not end up generating this one |
| registered [Feature] | Check if a given feature is registered. |
| removeOffset [Cil] | Remove ONE offset from the end of an offset sequence. |
| removeOffsetLval [Cil] | Remove ONE offset from the end of an lvalue. |
| repeattime [Stats] | repeattime is like time but runs the function several times until the total running time is greater or equal to the first argument. |
| reset [Stats] | Resets all the timings and specifies the method to use for future timings. |
| resetEscStr [Errormsg] | |
| rev [Clist] | Reverse a clist. |
S | |
| s [Errormsg] | Stop the execution by raising an Error. |
| saveBinaryFile [Cil] | Write a |
| saveBinaryFileChannel [Cil] | Write a |
| separateStorageModifiers [Cil] | Separate out the storage-modifier name attributes |
| seq [Pretty] | Formats a sequence. |
| setCurrentFile [Errormsg] | |
| setCurrentLine [Errormsg] | |
| setFormals [Cil] | Update the formals of a |
| setFunctionType [Cil] | Set the types of arguments and results as given by the function type passed as the second argument. |
| setFunctionTypeMakeFormals [Cil] | Set the type of the function and make formal arguments for them |
| setHFile [Errormsg] | |
| setHLine [Errormsg] | |
| setMaxId [Cil] | Update the smaxid after you have populated with locals and formals
(unless you constructed those using |
| setTypeAttrs [Cil] | |
| setTypeSigAttrs [Cil] | Replace the attributes of a signature (only at top level) |
| showContext [Errormsg] | Show the context stack to stderr |
| signedVersionOf [Cil] | Give the signed kind corresponding to any integer kind |
| single [Clist] | Create a clist containing one element |
| sizeOf [Cil] | The size of a type, in bytes. |
| splitFunctionType [Cil] | Given a function type split it into return type, arguments, is_vararg and attributes. |
| splitFunctionTypeVI [Cil] | Same as |
| sprint [Pretty] | Format the document to the given width and emit it as a string |
| startParsing [Errormsg] | |
| startParsingFromString [Errormsg] | |
| start_id [Cfg] | Next statement id that will be assigned. |
| startsWith [Cil] | sm: return true if the first is a prefix of the second string |
| stmtStartData [Dataflow.BackwardsTransfer] | For each block id, the data at the start. |
| stmtStartData [Dataflow.ForwardsTransfer] | For each statement id, the data at the start. |
| stripCasts [Cil] | Removes casts from this expression, but ignores casts within other expression constructs. |
| stripUnderscores [Cil] | If string has leading and trailing __, strip them. |
T | |
| test [Formatcil] | Just a testing function |
| text [Pretty] | A document that prints the given string |
| time [Stats] | Time a function and associate the time with the given string. |
| timethis [Stats] | Time a function and set lastTime to the time it took |
| toList [Clist] | Convert a clist to an ordinary list |
| truncateCilint [Cil] | Represents an integer as for a given kind. |
| truncateInteger64 [Cil] | |
| typeAddAttributes [Cil] | Add some attributes to a type |
| typeAttrs [Cil] | Returns all the attributes contained in a type. |
| typeOf [Cil] | Compute the type of an expression |
| typeOfLval [Cil] | Compute the type of an lvalue |
| typeOfSizeOf [Cil] | An unsigned integer type that is the type of sizeof. |
| typeOffset [Cil] | Compute the type of an offset from a base type |
| typeRemoveAttributes [Cil] | Remove all attributes with the given names from a type. |
| typeSig [Cil] | Compute a type signature |
| typeSigAttrs [Cil] | Get the top-level attributes of a signature |
| typeSigWithAttrs [Cil] | Like |
U | |
| uintPtrType [Cil] | unsigned int * |
| uintType [Cil] | unsigned int |
| ulongType [Cil] | unsigned long |
| unalign [Pretty] | Reverts to the last saved indentation level. |
| underscore_name [Cil] | Whether the compiler generates assembly labels by prepending "_" to the identifier. |
| undoAlphaChanges [Alpha] | Undo the changes to a table |
| unimp [Errormsg] | Similar to |
| unimp [Cil] | Like |
| uniqueVarNames [Cil] | Assign unique names to local variables. |
| unmark [Pretty] | The end of a markup section |
| unrollType [Cil] | Unroll a type until it exposes a non
|
| unrollTypeDeep [Cil] | Unroll all the TNamed in a type (even under type constructors such as
|
| unsignedVersionOf [Cil] | Give the unsigned kind corresponding to any integer kind |
| upointType [Cil] | An unsigned integer type that fits pointers. |
| useCaseRange [Cil] | Whether to expand ranges of values in case statements. |
| useComputedGoto [Cil] | Whether to use GCC's computed gotos. |
| useLogicalOperators [Cil] | Whether to use the logical operands LAnd and LOr. |
V | |
| var [Cil] | Makes an lvalue out of a given variable |
| verboseFlag [Errormsg] | |
| visitCilAttributes [Cil] | Visit a list of attributes |
| visitCilBlock [Cil] | Visit a block |
| visitCilExpr [Cil] | |
| visitCilFile [Cil] | Visit a file. |
| visitCilFileSameGlobals [Cil] | A visitor for the whole file that does not change the globals (but maybe changes things inside the globals). |
| visitCilFunction [Cil] | Visit a function definition |
| visitCilGlobal [Cil] | Visit a global |
| visitCilInit [Cil] | Visit an initializer, pass also the variable to which this belongs and the offset. |
| visitCilInitOffset [Cil] | Visit an initializer offset |
| visitCilInstr [Cil] | Visit an instruction |
| visitCilLval [Cil] | Visit an lvalue |
| visitCilOffset [Cil] | Visit an lvalue or recursive offset |
| visitCilStmt [Cil] | Visit a statement |
| visitCilType [Cil] | Visit a type |
| visitCilVarDecl [Cil] | Visit a variable declaration |
| voidPtrType [Cil] | void * |
| voidType [Cil] | void |
W | |
| warn [Errormsg] | Like |
| warn [Cil] | Like |
| warnContext [Cil] | Like |
| warnContextOpt [Cil] | Like |
| warnFlag [Errormsg] | Set to true if you want to see all warnings. |
| warnLoc [Cil] | Like |
| warnOpt [Errormsg] | Like |
| warnOpt [Cil] | Like |
| warnTruncate [Cil] | Emit warnings when truncating integer constants (default true) |
| wcharKind [Cil] | wchar_t (depends on architecture) and is set when you call
|
| wcharType [Cil] | |
| whiteEscStr [Errormsg] | |
| withContext [Errormsg] | To ensure that the context is registered and removed properly, use the function below |
| withPrintDepth [Pretty] | Invokes a thunk, with printDepth temporarily set to the specified value |
Y | |
| yellowEscStr [Errormsg] | |
Z | |
| zero [Cil] | 0 |


| PostgreSQL 9.5.19 Documentation | |||
|---|---|---|---|
| Prev | Up | Chapter 17. Server Setup and Operation | Next |
Before you can do anything, you must initialize a database storage area on disk. We call this a database cluster. (The SQL standard uses the term catalog cluster.) A database cluster is a collection of databases that is managed by a single instance of a running database server. After initialization, a database cluster will contain a database named postgres, which is meant as a default database for use by utilities, users and third party applications. The database server itself does not require the postgres database to exist, but many external utility programs assume it exists. Another database created within each cluster during initialization is called template1. As the name suggests, this will be used as a template for subsequently created databases; it should not be used for actual work. (See Chapter 21 for information about creating new databases within a cluster.)
In file system terms, a database cluster is a single directory under which all data will be stored. We call this the data directory or data area. It is completely up to you where you choose to store your data. There is no default, although locations such as /usr/local/pgsql/data or /var/lib/pgsql/data are popular. To initialize a database cluster, use the command initdb, which is installed with PostgreSQL. The desired file system location of your database cluster is indicated by the -D option, for example:
$ initdb -D /usr/local/pgsql/data
Note that you must execute this command while logged into the PostgreSQL user account, which is described in the previous section.
Tip: As an alternative to the -D option, you can set the environment variable PGDATA.
Alternatively, you can run initdb via the pg_ctl program like so:
$ pg_ctl -D /usr/local/pgsql/data initdb
This may be more intuitive if you are using pg_ctl for starting and stopping the server (see Section 17.3), so that pg_ctl would be the sole command you use for managing the database server instance.
initdb will attempt to create the directory you specify if it does not already exist. Of course, this will fail if initdb does not have permissions to write in the parent directory. It's generally recommendable that the PostgreSQL user own not just the data directory but its parent directory as well, so that this should not be a problem. If the desired parent directory doesn't exist either, you will need to create it first, using root privileges if the grandparent directory isn't writable. So the process might look like this:
root# mkdir /usr/local/pgsql root# chown postgres /usr/local/pgsql root# su postgres postgres$ initdb -D /usr/local/pgsql/data
initdb will refuse to run if the data directory exists and already contains files; this is to prevent accidentally overwriting an existing installation.
Because the data directory contains all the data stored in the database, it is essential that it be secured from unauthorized access. initdb therefore revokes access permissions from everyone but the PostgreSQL user.
However, while the directory contents are secure, the default client authentication setup allows any local user to connect to the database and even become the database superuser. If you do not trust other local users, we recommend you use one of initdb's -W, --pwprompt or --pwfile options to assign a password to the database superuser. Also, specify -A md5 or -A password so that the default trust authentication mode is not used; or modify the generated pg_hba.conf file after running initdb, but before you start the server for the first time. (Other reasonable approaches include using peer authentication or file system permissions to restrict connections. See Chapter 19 for more information.)
initdb also initializes the default locale for the database cluster. Normally, it will just take the locale settings in the environment and apply them to the initialized database. It is possible to specify a different locale for the database; more information about that can be found in Section 22.1. The default sort order used within the particular database cluster is set by initdb, and while you can create new databases using different sort order, the order used in the template databases that initdb creates cannot be changed without dropping and recreating them. There is also a performance impact for using locales other than C or POSIX. Therefore, it is important to make this choice correctly the first time.
initdb also sets the default character set encoding for the database cluster. Normally this should be chosen to match the locale setting. For details see Section 22.3.
Non-C and and non-POSIX locales rely on the operating system's collation library for character set ordering. This controls the ordering of keys stored in indexes. For this reason, a cluster cannot switch to an incompatible collation library version, either through snapshot restore, binary streaming replication, a different operating system, or an operating system upgrade.
Many installations create their database clusters on file systems (volumes) other than the machine's "root" volume. If you choose to do this, it is not advisable to try to use the secondary volume's topmost directory (mount point) as the data directory. Best practice is to create a directory within the mount-point directory that is owned by the PostgreSQL user, and then create the data directory within that. This avoids permissions problems, particularly for operations such as pg_upgrade, and it also ensures clean failures if the secondary volume is taken offline.
Many installations create their database clusters on network file systems. Sometimes this is done via NFS, or by using a Network Attached Storage (NAS) device that uses NFS internally. PostgreSQL does nothing special for NFS file systems, meaning it assumes NFS behaves exactly like locally-connected drives. If the client or server NFS implementation does not provide standard file system semantics, this can cause reliability problems (see http://www.time-travellers.org/shane/papers/NFS_considered_harmful.html). Specifically, delayed (asynchronous) writes to the NFS server can cause data corruption problems. If possible, mount the NFS file system synchronously (without caching) to avoid this hazard. Also, soft-mounting the NFS file system is not recommended.
Storage Area Networks (SAN) typically use communication protocols other than NFS, and may or may not be subject to hazards of this sort. It's advisable to consult the vendor's documentation concerning data consistency guarantees. PostgreSQL cannot be more reliable than the file system it's using.


{% extends "layout.html" %} {% block page_title %} Prototype kit interface inventory {% endblock %} {% block content %} {{ macro.breadcrumb() }} Prototype kit interface inventory Note: the heading structure is broken on this page Links and buttons Start call to action Start now Default call to action Submit Start Link with visually hidden text Change Exporter name Content Content with a change of language The online service is also available in Welsh (Cymraeg). Highlight box Application complete Your reference number is HDJ2123F User data Organisations involved Producer Producer name Change Producer name Related Link Carers and disability benefits Carer's Allowance Carer's Credit More in Carers and disability benefits Disclosure Help with date of birth If you don’t know your exact date of birth, use the one you put on official documents (for example, your passport or driving licence). If you can’t provide your date of birth you’ll have to send copies of identity documents through the post. Forms Text field with hint Full name As shown on your birth certificate or passport Date of birth Date of birth Date of birth For example, 31 3 1980 Day Month Year Address Your address Your address Street Street Town or City Postcode Checkboxes with conditional reveal What is your nationality? If you have dual nationality, select all options that are relevant to you. What is your nationality? British Irish Citizen of another country Country name Radio button Which part of the Housing Act was your licence issued under? Select one of the options below. Which part of the Housing Act was your licence isued under? Part 2 of the Housing Act 2004 For properties that are 3 or more stories high and occupied by 5 or more people Part 3 of the Housing Act 2004 For properties that are within a geographical area defined by a local council {% endblock %}
Note: the heading structure is broken on this page
The online service is also available in Welsh (Cymraeg).
Your reference number is HDJ2123F
If you don’t know your exact date of birth, use the one you put on official documents (for example, your passport or driving licence).
If you can’t provide your date of birth you’ll have to send copies of identity documents through the post.
For example, 31 3 1980
If you have dual nationality, select all options that are relevant to you.
Select one of the options below.


This guide discusses how to create Box2D physical bodies in your Corona app, including polygonal and multi-element bodies.
The physics world is based on the interactions of physical bodies. Corona treats these physical bodies as an extension of its graphics objects. These bodies can be bound to Corona display objects in a
Standard object read/write attributes like x
, y
, and rotation
should continue to work normally on physical bodies. However, if the object's bodyType
is dynamic, the physics engine may "fight back" against your attempts to move the object manually, since it may be under the constant effect of gravity or other forces.
A display object with a physical body can be deleted in the usual way, using either object:removeSelf() or display.remove(). In this case, it will be removed from both the visible screen and the physical simulation (the physical body data will be destroyed). Alternatively, you can use physics.removeBody() to remove just the physical body while retaining the core display object on screen. See Destroying Objects for more details and an important note regarding collisions.
All physical bodies in Corona are created with the physics.addBody() function. This allows you to turn any Corona display object into a simulated physical object with just one line of code, including the assignment of physical properties.
physics.addBody( object, { properties } )
All physical bodies possess three core properties, and each can be defined as a key-value pair in the properties table. These properties are optional and the default values will apply unless otherwise specified.
density
is multiplied by the area of the body's shape to determine its mass. This parameter is based on a standard value of 1.0
for water, so materials that are lighter than water (such as wood) have a density below 1.0
, and heavier materials (such as stone) have a density greater than 1.0
. However, feel free to set density values to whatever feels right for your simulation, since overall object behavior will also depend on the gravity and 1.0
.
friction
may be any non-negative value. A value of 0
means no friction and 1.0
means fairly strong friction. The default value is 0.3
.
bounce
is the Box2D property known as "restitution," and it determines how much of an object's velocity is returned after a collision. Values greater than 0.3
are fairly "bouncy," and an object with a bounce value of 1.0
will rebound forever — for example, if the object is dropped to the ground, it will bounce back up to approximately the height from which it was dropped. Bounce values higher than 1.0
are valid, and they will actually gain velocity with each collision. The default value is 0.2
, which is slightly bouncy.
--examples:
local crate = display.newImage( "crate.png", 100, 200 )
physics.addBody( crate, { density=1.0, friction=0.3, bounce=0.2 } )
local balloon = display.newImage( "balloon.png", 200, 200 )
physics.addBody( balloon, { density=0.1, friction=0.1, bounce=0.4 } )
Note that a pre-declared table of physical attributes can be used multiple times:
local crate1 = display.newImage( "crate1.png", 100, 200 )
local crate2 = display.newImage( "crate2.png", 180, 280 )
local crateMaterial = { density=1.0, friction=0.3, bounce=0.2 }
physics.addBody( crate1, crateMaterial )
physics.addBody( crate2, crateMaterial )
Physical bodies can be one of three types: dynamic, static, or kinematic.
Dynamic bodies are fully simulated. They can be moved manually in code, but normally they move according to forces like gravity or reactionary collision forces. This is the default body type for physical objects in Box2D. Dynamic bodies can collide with all body types.
Static bodies does not move under simulation and they behave as if they have infinite mass. Static bodies can be moved manually by the user, but they do not accept the application of velocity. Static bodies collide only with dynamic bodies, not with other static bodies or kinematic bodies.
Kinematic bodies move under simulation only according to their velocity. Kinematic bodies will not respond to forces like gravity. They can be moved manually by the user, but normally they are moved by setting their velocities. Kinematic bodies collide only with dynamic bodies, not with other kinematic bodies or static bodies.
As noted, some body types will — or will not — collide with other body types. In a collision between two physical objects, at least one of the objects must be dynamic, since this is the only body type which collides with any other type.
Declaring the body type in Corona is done either inline with the physics.addBody()
call or post-creation using object.bodyType.
--inline:
physics.addBody( triangle, "static", { density=1.6, friction=0.5, bounce=0.2 } )
--post-creation:
physics.addBody( triangle, { density=1.6, friction=0.5, bounce=0.2 } )
triangle.bodyType = "static"
By default, the physics.addBody()
constructor will apply a rectangular body that surrounds the edges of the associated image or vector object. This is useful for platforms, large ground bodies, and other simple rectangular objects. Note that this rectangle includes the transparent pixels around an image, if any exist.
local platform = display.newImage( "platform.png", 600, 200 )
physics.addBody( platform, { density=1.0, friction=0.3, bounce=0.2 } )
If you don't want the physical body to match this bounding rectangle, you must define more specific shape data using either the circular radius
property or a table of polygon coordinates (see below).
When in doubt, use physics.setDrawMode() to check how the physics engine is actually considering the object.
Circular bodies are created by adding the radius
parameter to the properties table. This works well for balls, rocks, and other objects that can be considered approximately round when calculating collisions.
local ball = display.newImage( "ball.png", 100, 100 )
physics.addBody( ball, { radius=50, density=1.0, friction=0.3, bounce=0.2 } )
Note that a non-circular oval does not exist in Box2D collision geometry, since circular bodies exist as a special case. To make an oval body, consider a table of polygon coordinates (see below).
Polygonal bodies can be created using the shape
parameter. This is a Lua table of x and y coordinate pairs, where each pair defines a vertex point for the shape. These coordinates are specified relative to the center of the display object — thus, with (0,0)
corresponding to the center of the object, a vertex point of (-20,-10)
defines a point 20 pixels to the left of center and 10 pixels above center.
--triangle:
local triangle = display.newImage( "triangle.png" )
triangle.x = 200
triangle.y = 150
--define the shape table (once created, this can be used multiple times)
local triangleShape = { 0,-35, 37,30, -37,30 }
physics.addBody( triangle, { shape=triangleShape, density=1.6, friction=0.5, bounce=0.2 } )
--pentagon:
local pentagon = display.newImage( "pentagon.png" )
pentagon.x = 200
pentagon.y = 50
local pentagonShape = { 0,-37, 37,-10, 23,34, -23,34, -37,-10 }
physics.addBody( pentagon, { shape=pentagonShape, density=3.0, friction=0.8, bounce=0.3 } )
Vertex points must be defined in clockwise order. The body may appear correct in the hybrid
or debug
views even if you specify the vertex points in
Polygonal shapes must be entirely convex. You cannot create shapes with concave bends, for example a bowl or cup. To accomplish such a task, you must assemble the body from multiple polygons, as explained in Multi-Element Bodies below.
Polygonal shapes may have a maximum of 8 vertex points and thus a maximum of 8 sides. If more are required, you must assemble the body from multiple neighboring polygons.
Applications such as PhysicsEditor can assist in the creation of polygonal bodies that obey the above rules.
The above examples assume a body with only one element — either a rectangle, circle, or convex polygon. However, in more advanced situations, you will need to construct bodies from multiple polygons to achieve more precise collision boundaries. Also, since polygons in Box2D must be convex, any object with a concave shape must be constructed by assembling multiple body elements.
When creating multi-element bodies, each element must be specified as a separate polygonal shape. Although these shapes are declared individually, they will be regarded as part of the overall body and they will not shift/flex independently under the application of physical forces.
The constructor for a multi-element body is essentially the same as the simple polygon constructor — just declare the additional elements after the first:
physics.addBody( object, "static",
{ bodyElement1 },
{ bodyElement2 },
--etc.
)
Note that each body element may have its own unique physical properties along with the shape definition for its collision boundaries. For example:
local car = display.newImage( "car.png" )
local roofShape = { -20,-10, 20,-10, 20,10, -20,10 }
local hoodShape = { 0,-35, 37,30, -37,30 }
local trunkShape = { 0,-37, 37,-10, 23,34, -23,34, -37,-10 }
physics.addBody( car, "dynamic",
{ density=3.0, friction=0.5, bounce=0.2, shape=roofShape },
{ density=6.0, friction=0.6, bounce=0.4, shape=hoodShape },
{ density=4.0, friction=0.5, bounce=0.4, shape=trunkShape }
)
Physical bodies can be destroyed like other display objects, using either object:removeSelf() or display.remove(). In this case, the object will be removed from both the visible screen and the physical simulation (the physical body data will be destroyed).
object:removeSelf()
--OR:
display.remove( object )
Alternatively, you can use physics.removeBody() to remove just the physical body while retaining the core display object on screen:
physics.removeBody( object )
In both cases, the Box2D body will be safely retained until the end of the current world step. However, its Lua reference will be deleted immediately. Therefore, you should avoid accidental, multiple removal of the same Lua object. This may arise when handling object collisions which can potentially trigger multiple event phases before the collision is fully resolved. To prevent this from occurring, use conditional filtering of the event.phase
, for example:
local function onCollision( self, event )
if ( event.phase == "began" ) then
display.remove( crate1 )
crate1 = nil
end
end
Any body — or any specific element of a multi-element body — can be turned into a sensor. Sensors do not physically interact with other bodies, but they produce collision events when other bodies pass through them. This is useful if you need to detect when an object collides with a specific region (the sensor), but not cause any force reaction as a result.
Setting a body element as a sensor is done either inline with the physics.addBody()
call or post-creation using object.isSensor.
--inline:
physics.addBody( goal, "static", { isSensor=true } )
--post-creation:
physics.addBody( goal, "static" )
goal.isSensor = true
Objects that collide with a sensor will trigger a "began"
event phase, just like normal non-sensor objects, and they will also trigger an "ended"
event phase when they exit the collision bounds of the sensor. In addition, collision events will occur for each element in a
In Corona, many of the native Box2D set/get methods have been reduced to simple properties on the display object. The following examples assume that a physical body object
has been created using one of the constructor methods.
object.bodyType is a string value for the type of physical body. Possible values include dynamic
, static
, or kinematic
. See the Body Type section for details. Note that you cannot change the body type during a collision event, so you must queue this event after a slight, imperceptible delay:
local function onCollisionDelay()
--change the body type
object.bodyType = "kinematic"
end
timer.performWithDelay( 10, onCollisionDelay )
object.isAwake is the boolean value for the body's current "awake" state.  This property can either fetch an object's current state or forcibly wake it up.
object.isSleepingAllowed is the boolean value for whether the body is ever allowed to sleep. Keeping a body awake has a larger performance overhead and usually it's not necessary because a collision with another body will automatically wake it up. However, forcing a constant awake state is useful in cases such as a tilt gravity simulation, since sleeping bodies do not respond to changes in global gravity.
object.isBodyActive is used to set or get the body's current active state. Inactive bodies are not destroyed, but they are removed from the physics simulation and cease to interact with other bodies. Note that you cannot change the body's active state during a collision event, so you must queue this event after a slight, imperceptible delay:
local function onCollisionDelay()
--change the body's active state to false
object.isBodyActive = false
end
timer.performWithDelay( 10, onCollisionDelay )
object.isSensor is a write-only boolean property that sets an internal isSensor=true
property across all elements in the body. See the Sensors section for more details. Because this property acts across all body elements, it unconditionally overrides any isSensor
settings on the individual elements.
object.isFixedRotation is the boolean value for whether the body's rotation should be locked, even if the body is subjected to off-center forces.
object.gravityScale can be used to adjust the gravity effect on a specific body. For example, setting it to 0
makes the body float, even if other objects in the simulation are subject to normal gravity. The default value is 1.0
, meaning normal gravity. You can also set the value higher than normal, but be careful since increased gravity can decrease stability.
--make the object float in place, even if the simulation has normal gravity
object.gravityScale = 0
object.angularVelocity is the numerical value of the current angular (rotational) velocity, in degrees per second.
object.angularDamping is the numerical value for how much the body's rotation should be damped — as in, how quickly the rotating object will slow down to a full stop in the rotational sense (not linear). The default is 0
, meaning the body will rotate at the same velocity indefinitely.
object.linearDamping is the numerical value for how much the body's linear motion is damped — as in, how quickly the object will slow down to a full stop in the linear sense (not rotational). The default is 0
, meaning the body will move at the same velocity indefinitely.
Note that the application of constant linear velocity is accomplished through the object:setLinearVelocity() method described below, unlike the angular/rotational velocity which is set via the object.angularVelocity property.
object.isBullet is the boolean value for whether the body should be treated as a "bullet" in respect to collision detection. Bullets are subject to continuous collision detection rather than periodic detection. This is computationally more expensive, but it can prevent
The following examples assume that a physical body object
has been created using one of the constructor methods.
object:setLinearVelocity() sets the x and y components for the body's linear velocity, in pixels per second.
object:setLinearVelocity( 2, 4 )
object:getLinearVelocity() returns the x and y components for the body's linear velocity, in pixels per second. This function takes advantage of the fact that Lua can return multiple values, in this case both linear velocities.
local vx, vy = object:getLinearVelocity()
print( "Linear X velocity = " .. vx )
print( "Linear Y velocity = " .. vy )
object:applyForce() applies the specified x and y components of a linear force at a given point within world coordinates. If the target point is the body's center of mass, it will tend to push the body in a straight line. If the target point is offset from the center, the body will spin around its center of mass. For symmetrical objects, the center of mass and the center of the object will have the same position:
object:applyForce( 500, 2000, object.x, object.y )
object:applyLinearImpulse() is similar to object:applyForce()
, except that an impulse is a single, momentary jolt of force. See the Force and Impulse notes below. Like object:applyForce()
, the impulse can be applied to any point on the body (either the center of mass or an offset point).
object:applyLinearImpulse( 60, 20, object.x, object.y )
object:applyTorque() applies a rotational force to the body. Positive values will result in clockwise torque; negative values will result in counter-clockwise torque. The body will rotate about its center of mass.
object:applyAngularImpulse() is similar to object:applyTorque()
, except that an impulse is a single, momentary jolt of force. See the Force and Impulse notes below.
object:resetMassData() is useful if the default mass data for the body has been overridden. This function resets it to the mass calculated from the shapes.
A common question is whether to apply force or impulse to a body. The difference is that an impulse is meant to simulate an immediate jolt/kick to the body, while force (and torque) is something exerted over time. Therefore, to get a realistic force/torque simulation, you should continually apply it on every application cycle, for as long as you want the force to continue. You can use a Runtime enterFrame event for this purpose:
local object = display.newImageRect( "leaf.png", 40, 40 )
object.x, object.y = 200,200
physics.addBody( object, "dynamic", { radius=20 } )
local function constantForce()
object:applyForce( 2, -4, object.x, object.y )
object:applyTorque( 2 )
end
Runtime:addEventListener( "enterFrame", constantForce )


Education
University of California, Los Angeles
Bachelor of Science in Computer Science
09/2014 - 06/2018
Course Taken
Operating Systems, Computer Networks,
Software Engineering, Programming Languages, Algorithms, Machine Learning, Computer System Architecture,
Artificial Intelligence, Computer Graphics
Northeastern University
Master of Science in Computer Science
09/2018 - 12/2020
Course Taken
Algorithms, Program Design Paradigms, Game AI,
Computer System, Information Retrieval, Database Management System, Web Development,
Mobile Software Development


Get help fast
DevDesk is designed to get you the help you need for technical questions, quickly and easily. Just submit a ticket and your request is sent to people who can help you, right now.
Support from your community
Support is provided by an engaged community of fellow learners, who are ready to help you solve any technical questions you might have.
Learn in public
When you ask questions, everyone learns. DevDesk makes it easy to find questions other people have asked, so that answers to questions continue to help people.


--- layout: page title: Say Hello to meeee permalink: /contact/ ---
If you really need to get in contact with me, I'd prefer you tweet me at @zivcjs or get at me on Github @zivc.


Kenya’s Equity Bank to acquire Congolese lender at $105m
by JAMES ANYANZWAIn Summary
- Equity Bank Chief Executive James Mwangi said the acquisition provides more impetus for the Kenyan-based lender to push ahead with its dream of converting into a pan African bank by 2024.
Regional lender Equity Group is in the final stages of completing its takeover of the Banque commercial du Congo, (BCDC).
This follows an agreement with the majority shareholder—George Arthur Forrest and family—to acquire all the 625,354 shares (66.53 per cent) owned by the Belgian at a cost of $105 million.
The price of the transaction includes dividends declared after January 1, 2019 in respect of the financial year ending December 31, 2019, meaning cum-dividend price per share of $ 167.9 per share.
However, Equity’s stock on the Nairobi Securities Exchange (NSE) declined by 0.94 per cent at 12.25 pm Tuesday to Ksh47.50($0.475) per share from Ksh47.95 ($0.479) on Monday as news of the lender’s proposed Congolese acquisition filtered through the investment circles.
In a statement Tuesday, Equity Bank Chief Executive James Mwangi said the acquisition provides more impetus for the Kenyan-based lender to push ahead with its dream of converting into a pan African bank by 2024.
“This is an opportunity for the Group to take further steps towards the delivery of its vision of building sub-Saharan Africa’s premier financial institution through delivering innovative products and services to customers, including, in particular, the effective use of technology,” said Dr Mwangi.
Also Read
-
Striking unions pile pressure on South African Airways
-
Sidian Bank gets $20m loan from Dutch lender
-
Kenyan student sues Equity Bank over song
-
Joe Muganda to exit Vivo Energy Kenya
Advertisement
APPROVALS
The transaction is still subject to regulatory approvals including the Central Bank of Kenya (CBK), Banque Centrale du Congo, the COMESA Competition Commission (CCC) and the board approvals of BCDC and Equity Group Holdings.
The BCDC is majority owned by George Arthur Forrest and family (66.53 per cent) and the government of the Democratic Republic of Congo (25.53 per cent) while the remaining 7.94 per cent shares are owned by other minority shareholders.
Currently Equity bank, with more than 14 million customers, has 289 branches across the region with operations in Kenya, Uganda, Rwanda, Tanzania, South Sudan and the DRC.
In September this year, the lender announced plans to strengthen its subsidiary in DRC by acquiring BCDC and merging its business with the Equity Bank Congo S.A (EBC).
The BCDC is the second largest lender in DRC by assets estimated at $700 million.
Equity already has operations in DRC through a subsidiary it established by acquiring 86 per cent stake in Pro Credit Bank, the then seventh largest bank in the country by assets exceeding $200 million and a customer base of over 170,000, between 2015 and 2017.
But the lender has also proposed to increase its shareholding in EBC S.A by acquiring an additional 7.6 per cent of the shares currently held by the German state-owned development bank, KfW.
The proposed acquisition is also subject to the approval of Banque Centrale du Congo.
If the acquisition is approved, it will effectively push Equity Bank’s shareholding in EBC S.A to about 94 per cent, with the remaining six (6) per cent left in the hands of the International Finance Corporation (IFC).


Code Coverage |
|||||||||
Lines |
Functions and Methods |
Classes and Traits |
|||||||
| Total | |
84.75% |
478 / 564 |
|
64.52% |
60 / 93 |
|
20.00% |
3 / 15 |
| Application | |
60.53% |
46 / 76 |
|
22.22% |
2 / 9 |
|
33.33% |
1 / 3 |
| Domain | |
87.47% |
370 / 423 |
|
68.00% |
51 / 75 |
|
11.11% |
1 / 9 |
| Exception | n/a |
0 / 0 |
n/a |
0 / 0 |
n/a |
0 / 0 |
|||
| Helper | |
95.38% |
62 / 65 |
|
77.78% |
7 / 9 |
|
33.33% |
1 / 3 |


Class for the database
Deletes a categories directory
# File lib/repomate/database.rb, line 25 25: def destroy 26: FileUtils.rm_r(@dbfile) if exists? 27: end
Disabled; run with --debug to generate this.
Generated with the Darkfish Rdoc Generator 1.1.6.


If your project requires a clean workspace for each build, select this option. This will delete all contents inside the workspace folder at the beginning of each build. A side-effect of this is that you will end up doing a fresh checkout from source control for each build.
It's possible to use Project cascading feature for this property. Please review this document.


Will Epperson
I’m a Ph.D. student in the HCII at CMU advised by Dominik Moritz and Adam Perer.
I build interactive tools to help data scientists better understand and make decisions with their data by automating the tedious parts of analysis and letting analysts spend more time focused on data insights. Data quality issues are often “silent” – models will still train but predictions will be inaccurate or dashboards may unknowingly present inaccurate metrics, making data understanding and debugging a critical part of analysis. My research explores how to best support data debugging through tools that model user interest during analysis, augment their data programming environment with automatic visualization, and support reusing previous analysis workflows.
Education
August 2020 - Present
Ph.D. in Human Computer Interaction
Carnegie Mellon University
Advisors:
Dominik Moritz,
Adam Perer
Sample Coursework:
HCI Process and Theory,
Computational Medicine,
Human Judgement and Decision Making,
Causality and ML,
Advanced NLP
August 2016 — May 2020
B.S. in Computer Science
Georgia Institute of Technology
GPA: 4.0, Summa Cum Laude, threads in Intelligence and Modeling/Simulation
Sample Coursework:
Machine Learning,
Deep Learning,
Computer Vision,
Computer Architecture,
Algorithms,
Computer Simulation,
Information Visualization
Publications
Leveraging Analysis History for Improved In Situ Visualization Recommendation
Will Epperson,
Doris Jung-Lin Lee,
Leijie Wang,
Kunal Agarwal,
Aditya Parameswaran,
Dominik Moritz,
Adam Perer
Solas is a visualization recommendation tool that uses the history of analysis for in situ recommendations in Jupyter.
EuroVis 22: Eurographics Conference on Visualization (EuroVis). Rome, Italy, 2022.
Project
PDF
Code
BibTeX
Strategies for Reuse and Sharing among Data Scientists in Software Teams
Will Epperson,
April Yi Wang,
Robert DeLine,
Steven M. Drucker
Interviews and a survey with 149 data scientists at Microsoft revealed five distinct strategies for sharing and reusing analysis code along with factors that encourage or discourage reuse.
ICSE 22: ACM International Conference on Software Engineering (ICSE). Pittsburgh, PA, 2022.
Project
PDF
Recording
Slides
BibTeX
Diff in the Loop: Supporting Data Comparison in Exploratory Data Analysis
April Yi Wang,
Will Epperson,
Robert DeLine,
Steven M. Drucker
Diff in the Loop supports tracking, comparing, and visualizing differences in datasets during iterative data analysis.
SIGCHI 22: ACM Symposium on Computer Human Interaction (CHI). New Orleans, LA, 2022.
Project
PDF
BibTeX
RECAST: Interactive Auditing of Automatic Toxicity Detection Models
Austin P. Wright,
Omar Shaikh,
Haekyu Park,
Will Epperson,
Muhammed Ahmed,
Stephane Pinel,
Diyi Yang,
Duen Horng (Polo) Chau
Interactive Auditing of Automatic Toxicity Detection Models
24th ACM Conference on Computer-Supported Cooperative Work & Social Computing. 2021.
Project
PDF
BibTeX
FairVis: Visual Analytics for Discovering Intersectional Bias in Machine Learning
Angel Cabrera,
Will Epperson,
Fred Hohman,
Minsuk Kahng,
Jamie Morgenstern,
Duen Horng (Polo) Chau
Discovering intersectional ML Bias through interactive visualization.
IEEE Conference on Visual Analytics Science and Technology (VAST). Vancouver, Canada, 2019.
Project
Demo
PDF
Blog
Recording
Code
BibTeX
Talks
Leveraging Analysis History for Improved In Situ Visualization Recommendation
June 2022EuroVis 22: Eurographics Conference on Visualization
Strategies for Reuse and Sharing among Data Scientists in Software Teams
May 2022ICSE 22: ACM International Conference on Software Engineering
FairVis
May 2019VIS 19: IEEE Visualization Conference
Honors and Awards
2019PURA: President's Undergraduate Research Award
$1500 research grant to continue work on FairVis project
2016Stamps President's Scholarship
Full ride scholarship given to 40 incoming freshman at Georgia Tech
Research Experience
August 2020 - PresentCarnegie Mellon University, Pittsburgh, PA
Graduate Researcher, Data Interaction Group (DIG)
Advisor:
Dominik Moritz,
Adam Perer
Member of the DIG research group, working on novel data visualizations, ML interpretation techniques, and interactive data systems.
Relevant Skills:
Python,
Javascript
January 2019 - May 2020Georgia Institute of Technology, Atlanta, GA
Undergraduate Researcher, Polo Club of Data Science
Advisor:
Duen Horng (Polo) Chau
Member of the Polo Club of Data Science working on novel data visualizations to find fairness issues in Machine Learning models
Relevant Skills:
Python,
Javascript
January 2018 - May 2019Georgia Institute of Technology, Atlanta, GA
Undergraduate Researcher, Automated Algorithm Design
Advisor:
Jason Zutty,
Greg Rohling
Worked on EMADE algorithm design engine to implement sentiment analysis pipeline to analyze news articles to aid in predicting stock price movements using genetic algorithms. Led project to visualize the genetic algorithm evolution process.
Relevant Skills:
Python,
Javascript
Industry Experience
Summer 2022Databricks, San Franciso, CA
Software Engineering Contractor
Mentor:
Kanit Wongsuphasawat
Designed and delivered production feature for creating dashboards by specifying fields of interest in a dataset.
Relevant Skills:
Typescript,
Python
Summer 2021Microsoft Research, Redmond, WA
Research Intern, VIDA Group
Mentor:
Steve Drucker,
Rob DeLine
Research intern working on data science tools. Lead project around reuse and sharing in data science, published at ICSE 2022. Also involved with project around visualizing data frame differenes published at CHI 2022.
Relevant Skills:
Python,
Typescript
Summer 2019Point72 Asset Management, New York, NY
Data Analytics Intern, Market Intelligence Group
Mentor:
Trevor Rempel
Worked as Data Scientist in alternative data space to clean, model, and understand large datasets
Relevant Skills:
Python,
Distributed Computing in Spark
Summer 2018Ultimate Software, Weston, FL
Software Development Intern, Innovation Strategies Team
Mentor:
Joseph Cutrono
Designed and developed Slack app to integrate with the UltiPro HR management tool. App published to Slack app store.
Relevant Skills:
Typescript,
REST API development
Summer 2015The Home Depot, Atlanta, GA
Software Development Intern
Developed web app for tracking candidate progress throughout hiring process for internal HR use.
Relevant Skills:
Java,
HTML/CSS/Javascript
Mentees
During my PhD, I have had the pleasure of mentoring the following undergraduate students on research projects.
Summer 2021 - Fall 2021
Leijie Wang
Visualization recommendation for python in notebooks using history
Fall 2021 - Spring 2022
Asad Sheikh
Visualization recommendation for SQL using history
Spring 2022+
Vaishnavi Gorantla
Fact generation from data and presentation as text
Teaching
Spring 2023Graduate Teaching Assistant
Carnegie Mellon University, Pittsburgh, PA
Programmable User Interfaces,
Instructor:
Scott Hudson
Taught recitation, designed assignments for class about UI design and intro HTML/CSS/Javascript.
Fall 2022Graduate Teaching Assistant
Carnegie Mellon University, Pittsburgh, PA
Interactive Data Science,
Instructor:
Adam Perer and John Stamper
Graded and office hours for class about using jupyter, visualization, steamlit and related tech for data science.
August 2017 - December 2018Undergraduate Teaching Assistant
Georgia Institute of Technology, Atlanta, GA
Intro to Database Systems (CS 4400),
Instructor:
Monica Sweat
Designed projects, held office hours and graded for relational databases class.
Leadership & Activities
January 2019 - May 2020 Student Ambassador
Georgia Institute of Technology Alumni Association
Serve as official representative of the Institute at events/tours for alumni, prospective students, and special guests.
January 2018 - May 2019 Executive Board Member -- Threads Co-chair
Stamps Scholars National Convention 2019
Executive board member of Stamps Scholars National Convention, a 3-day conference with over 700 student attendees. Responsible for 20-person committee that plans and coordinates the different content threads of the convention.
Skills
Programing Languages:
Python (Advanced),
Javascript/Typescript (Advanced),
SQL (Intermediate),
Java (Intermediate),
C (Basic)
Toolkits, Frameworks, Software:
Pytorch,
Scikit-learn,
Git,
VegaLite,
D3,
Tableau,
MacOS,
Windows,
Linux
Natural Languages:
English (Native),
Spanish (Advanced)


2 Samuel 12:5
And David's anger was greatly kindled against the man; and he said to Nathan, As the LORD liveth, the man that hath done this thing shall surely die:


Designing for interactions between multiple user sets can be tricky and is often a stumbling block for initial product design. It was important that we understood our 2 types of users needs well before proceeding with our design. Ultimately we decided to focus on the needs of our business owners first and design for them in our MVP.


USS Grayback, a WWII submarine lost 75 years ago, located off coast of Japan
by Kyle HicksOKINAWA, Japan – A World War II submarine that had been missing for more than 75 years has been located in the waters off Japan.
Explorer Tim Taylor’s Lost 52 Project team announced Sunday that the they had located the USS Grayback on June 5, 2019.
The Lost 52 Project says the sub was on its 10th war patrol when it was sunk by a Nakajima B5-N Carrier bomber on Feb. 26, 1944, killing 80 U.S. sailors.
The sub now lies 1,427 feet below the surface off the shore of Okinawa and its deck gun was found resting about 383 feet away, according to the organization.
The vessel was ranked 20th of all U.S. submarines in total tonnage sunk with 63,835 tons and 24th in number of ships sunk with 14, according to the Naval History and Heritage Command.
Taylor and his Lost 52 Project team has set out to find the wrecks of every American submarine lost in the war. So far, they’ve found five of 52 subs, ABC News reports .
"We do not tell people that we're looking for these because we don't want to disappoint people, and we don't want to blast it across the internet until it's done properly through the Navy," said Taylor to ABC News. "With the technology that we're using, and the ability to cover large swaths of ground, we're looking at the potential to find several more."


A model for table content, which may be extended for practical use cases
Constructor
Get the text contents of the cell
Argument: row
Row of the cell (y-index) Argument: col
Column of the cell (x-index)
Returns: s the text to display, or "" or undefined if there's nothing to display
get the number of rows
Returns: s the number of rows. Less or equal 0 indicates an empty table
get the number of columns
Returns: s the number of columns. Less or equal 0 indicates an empty table
Get the title of a column
Argument: col
the index of the column (0-indexed)
Returns: s the title of the given column


static
variables being lazily initialized
in a non-thread-safe manner. Lazy initialization of static
variables should be done
with an appropriate synchronization construct, to prevent different threads from
performing conflicting initialization.
When applicable, a quickfix is suggested which introduces the lazy initialization holder class idiom. This idiom makes use of the fact that the JVM guarantees that a class will not be initialized until it is used.
Unsafe lazy initialization example:
class X {
private static List<String> list;
public List<String> getList() {
if (list == null) {
list = List.of("one", "two", "tree");
}
return list;
}
}
Lazy initialization holder class idiom example:
class X {
private static final class ListHolder {
static final List<String> list = List.of("one", "two", "tree");
}
public List<String> getList() {
return ListHolder.list;
}
}


About me
Projects
Contact me!
Vedrana Hasanbasic
Send me a message!
First name:
Last Name:
Email:
Your message:
Send


Command-Line Utility
Using the Command-Line Utility
To perform a transformation, you can call Xalan-Java from the command line (or script), an applet, an application, or a servlet (see Usage Patterns).
The org.apache.xalan.xslt.Process main() method provides a command-line interface for performing XSL transformation. To perform a transformation from the command line or a script, do the following:
- Download Xalan-Java.
-
Set the Java classpath to include
xalan.jar
,serializer.jar
,xml-apis.jar
, andxercesImpl.jar
-- or another conformant XML Parser -- (see Plugging in the Transformer and XML parser).
- Call java and the Process class with the appropriate flags and
arguments (described below). The following command line, for example, includes the -IN, -XSL,
and -OUT flags with their accompanying arguments -- the XML source document, the XSL
stylesheet, and the output file:
java org.apache.xalan.xslt.Process -IN foo.xml -XSL foo.xsl -OUT foo.out
The command line utility can take the following flags and arguments (the flags are case insensitive):
Common Options -XSLTC (use XSLTC for transformation) -IN inputXMLURL -XSL XSLTransformationURL -OUT outputFileName -V (Version info) -EDUMP [optional filename] (Do stackdump on error.) -XML (Use XML formatter and add XML header.) -TEXT (Use simple Text formatter.) -HTML (Use HTML formatter.) -PARAM name expression (Set a stylesheet parameter) -MEDIA mediaType (use media attribute to find stylesheet associated with a document) -FLAVOR flavorName (Explicitly use s2s=SAX or d2d=DOM to do transform) -DIAG (Print overall milliseconds transform took) -URIRESOLVER full class name (URIResolver to be used to resolve URIs) -ENTITYRESOLVER full class name (EntityResolver to be used to resolve entities) -CONTENTHANDLER full class name (ContentHandler to be used to serialize output) -SECURE (set the secure processing feature to true) Options for Xalan-Java Interpretive -QC (Quiet Pattern Conflicts Warnings) -TT (Trace the templates as they are being called) -TG (Trace each generation event) -TS (Trace each selection event) -TTC (Trace the template children as they are being processed) -TCLASS (TraceListener class for trace extensions) -L (use line numbers for source document) -INCREMENTAL (request incremental DTM construction by setting http://xml.apache.org/xalan/features/incremental to true) -NOOPTIMIMIZE (request no stylesheet optimization proccessing by setting http://xml.apache.org/xalan/features/optimize to false) -RL recursionlimit (assert numeric limit on stylesheet recursion depth) Options for Xalan-Java Compiled (XSLTC) -XO [optional transletName] (assign the name to the generated translet) -XD destinationDirectory (specify a destination directory for translet) -XJ jarfile (package translet classes into a jar file of name <jarfile>) -XP package (specify a package name prefix for all generated translet classes) -XN (enable XSL template inlining into one big method) -XX (turn on additional debugging message output) -XT (use translet to transform if possible)
Use -XSLTC
if you want to transform with XSLTC. Please refer to
this document for a detailed description on
XSLTC related options.
Use -IN
to specify the XML source document.
Use -XSL
to specify the XSL stylesheet file.
Use -TEXT
if you want the output to include only element values (not element tags with element names and
attributes).
Use -HTML
to write 4.0 transitional HTML (some elements, such as <br>, are
not well formed XML).
To set stylesheet parameters from the command line, use
java org.apache.xalan.xslt.Process -PARAM
name value
The value is passed to the transformer as a String.
For information about incremental and optimized stylesheet processing, see DTM settings.
Use -L
to obtain access to a SourceLocator that a stylesheet extension can use to get information about the location
of nodes in the source document. For more information, see NodeInfo extension functions
and source_location.
Use -URIRESOLVER
with a fully qualified class name to utilize a custom implementation of the
URIResolver JAXP interface to resolve URIs for
xsl:include, xsl:import, and the document() function.
Use -ENTITYRESOLVER
with a fully qualified class name to utilize a custom implementation of the
EntityResolver SAX interface to handle external entity references.
Use -CONTENTHANDLER
with a fully qualified class name to utilize a custom implementation of the
ContentHandler SAX interface to serialize output.
If this same class implements the org.xml.sax.ext.LexicalHandler
interface and the output method is "xml", it will also receive lexical information about the XML document during serialization.
| If you want to validate an XML document (verify that it adheres to its DOCTYPE declaration), you can use the Validate utility shipped with Xalan-Java. |


Here's an exmaple of paragraph text that is being styled according to a style tag in the head of the HTML that makes it red.


Lisa Dee Fieldman
Unafffiliated
Self-employed attorney/alternative dispute resolution. Hearing officer for several housing authorities. Temporary municipal judge, City of Fort Collins (civil cases only). Business name Ad Hoc: Comprehensive Special Master Services. Previously Civil Litigation Magistrate, 20th Judicial District, Colorado, and Special Master, US Court of Federal Claims. Resume attached.
Colorado native, 1976 graduate of Arvada High School. B.A. Johns Hopkins Unitversity 1980; J.D. University of Colorado School of Law, 1987. 40 hour mediation certificate, Collaborative Growth, LLC.
80033
I have been a judicial officer and have therefore refrained from this activity.
Colorado Supreme Court Standing Committee on Civil Rules; Colorado Bar Association; Colorado Bar Foundation; Colorado Women's Bar Association; Colorado Municipal Judges Association; Thompson Marsh Inn of Court.
I was a Parish Social Ministry Coordinator for Catholic Community Services from 1985-1987, taught community organizing and development in that context. I represented members of the Arvada City Council in a land use and Open Records Act dispute that eventually lead to the creation of the Two Ponds National Wildlife Refuge. I helped the A-Line non-profit airport shuttle obtain its PUC operating permit. I collaborated in filing an amicus brief in the Taylor Ranch historic land use case.
These commissions are an exciting opportunity to implement small-d democracy in a transparent way that will galvanize participation and engagement at all stages of the process and I would like to be a part of that process.
I have been a judicial officer for almost 30 years. I believe I have acquired active listening and engagement skills during that service that help build consensus. I have learned when to help people stand their ground, and when to help them step aside. I have learned principled decision-making without being rigid or inflexible.
Expertise is valuable when it is applied appropriately and rationally. I have adjudicated complex medical and engineering cases to develop creative, innovative solutions to problems in those cases.
female


These are our pets
Gizmo, the King of Cora
Gizmo is a bully, but all the people love him
He roams the block and intimidates the other cats and gets pets and food from all the people
Azi, is he a cat or human?
- He sits up on the couch and watches TV
- Azi's favorite TV shows involve birds


--- layout: default categories: plugin title: mapbox-gl-geocoder prefix: mapbox-gl-geocoder description: Search for places on a map with the Mapbox Geocoding API tags: - bsd code: https://github.com/mapbox/mapbox-gl-geocoder license: BSD ---


|
|
| env_base () |
| | Simple constructor.
|
| |
|
bool | is_goal (const Waypoint &state) const |
| | Check if hit the goal region.
|
| |
| double | get_heur (const Waypoint &state, double t) const |
| | Heuristic function. More...
|
| |
|
double | cal_heur (const Waypoint &state, const Waypoint &goal) const |
| | calculate the cost from state to goal
|
| |
|
Vec3i | round (const Vec3f &vec, double res) const |
| | Replace the original cast function.
|
| |
|
Key | state_to_idx (const Waypoint &state) const |
| | Genegrate Key from state.
|
| |
|
void | forward_action (const Waypoint &curr, int action_id, Primitive &pr) const |
| | Recover trajectory.
|
| |
| void | set_discretization (int n, bool use_3d) |
| | Set discretization in control space. More...
|
| |
|
void | set_U (const vec_Vec3f &U) |
| | Set max U in each axis.
|
| |
|
void | set_v_max (decimal_t v) |
| | Set max vel in each axis.
|
| |
|
void | set_a_max (decimal_t a) |
| | Set max acc in each axis.
|
| |
|
void | set_j_max (decimal_t j) |
| | Set max acc in each axis.
|
| |
|
void | set_u_max (decimal_t u) |
| | Set max control in each axis.
|
| |
|
void | set_t_max (decimal_t t) |
| | Set max amount of time step to explore.
|
| |
|
void | set_prior_trajectory (const Trajectory &traj) |
| | Set prior trajectory.
|
| |
|
void | set_dt (decimal_t dt) |
| | Set dt for primitive.
|
| |
|
void | set_tol_dis (decimal_t dis) |
| | Set distance tolerance for goal region.
|
| |
|
void | set_tol_vel (decimal_t vel) |
| | Set velocity tolerance for goal region.
|
| |
|
void | set_tol_acc (decimal_t acc) |
| | Set velocity tolerance for goal region.
|
| |
|
void | set_w (decimal_t w) |
| | set weight for cost in time, usually no need to change
|
| |
|
void | set_wi (int wi) |
| | Set derivative order for cost in effort, dont need to set manually.
|
| |
|
void | set_alpha (int alpha) |
| | Set alpha.
|
| |
|
void | set_goal (const Waypoint &state) |
| | Set goal state.
|
| |
|
void | info () |
| | Print out params.
|
| |
|
virtual bool | is_free (const Vec3f &pt) const |
| | Check if a point is in free space.
|
| |
|
virtual bool | is_free (const Primitive &pr) const |
| | Check if a primitive is in free space.
|
| |
|
decimal_t | get_dt () const |
| | Retrieve dt.
|
| |
| virtual void | get_succ (const Waypoint &curr, std::vector< Waypoint > &succ, std::vector< Key > &succ_idx, std::vector< double > &succ_cost, std::vector< int > &action_idx) const |
| | Get successor. More...
|
| |


EXO drops detailed scientific moving poster for 6th album 'Obsession'
by KayRosaEXO has dropped new teasers for their comeback.
On November 4 KST, EXO shared two emblematic images containing the title of their upcoming album 'Obsession', as well as an eerie moving poster that imitates a scientific report. If you read closely, the contents of the report is dedicated to "Anomaly Detection", further explained by a lengthy description and a warning message.
Have these members been detected as exoplanet anomalies by earthlings? Read the full description above!
Stay tuned for more teasers until the full drop of EXO's 6th full album 'Obsession' on November 27.


The Immediate Execution Model uses market orders to immediately fill algorithm portfolio targets. It is the simplest Execution Model similar to simply placing Market Orders inline with your algorithm logic.
You can use this pre-made Execution Model by setting it in the Initialize method:
SetExecution( new ImmediateExecutionModel() );
self.SetExecution( ImmediateExecutionModel() )
It is implemented as demonstrated in the code snippet below:
// Issue market orders for the difference between holdings & targeted quantity public override void Execute(QCAlgorithmFramework algorithm, IPortfolioTarget[] targets) { foreach (var target in targets) { var existing = algorithm.Securities[target.Symbol].Holdings.Quantity + algorithm.Transactions.GetOpenOrders(target.Symbol).Sum(o => o.Quantity); var quantity = target.Quantity - existing; if (quantity != 0) { algorithm.MarketOrder(target.Symbol, quantity); } } }
# Issue market orders for the difference between holdings & targeted quantity def Execute(self, algorithm, targets): for target in targets: open_quantity = sum([x.Quantity for x in algorithm.Transactions.GetOpenOrders(target.Symbol)]) existing = algorithm.Securities[target.Symbol].Holdings.Quantity + open_quantity quantity = target.Quantity - existing if quantity != 0: algorithm.MarketOrder(target.Symbol, quantity)
You can view the complete C# implementation of this model in GitHub.You can view the complete Python implementation of this model in GitHub.


Penn State Fans Go Crazy After ‘Condom Balloon’ Scores Touchdown (VIDEO)
by Darrelle LincolnOn Saturday, the Penn State Nittany Lions took the field against the Indiana Hoosiers to a frenzy crowd who were having a great time all game long.
During one part of the game, a fan decided they were going to bring a condom inside the stadium, not for protection for what it’s created for, but to blow it up like a balloon and throw it down to the field.
That condom balloon not only made it, but scored a TD as the fans went wild.


@@include("./include/head.html")
@@include("./include/nav.html")
提交记录
只查看我的提交
@@include("./include/submission.html")


Collect the information outlined on your application checklist to begin your application. The more information you have about your event, the easier it should be to complete your application. Stuck on a question? Don't worry, you can log out at any time and come back to your question when you're ready. Answers will automatically be saved on your application so you can continue where you left off next time you sign in.
View Frequently Asked Questions (FAQS) located on the Help page for everything you need to know about SEPs.
Please ensure your legal name is used for the application and the information is correct. If you need to update your information, visit Manage AccountManage Account.
Please read and acknowledge the Terms and Conditions to begin your application:


Students found under the influence of Xanax
CHINO (INT) The prescription drug Xanax is finding its way onto school campuses.
Four students at Don Lugo High School and Ramona Junior High showed up under the influence of the anti-anxiety drug over a 3-day period. Each required hospital treatment.
Police mounted an investigation and arrested three students for possessing Xanax for sale. A 19-year-old Ontario youth was arrested for supplying the drug to the students.
Xanax is a controlled addictive drug that is illegal to obtain without a prescription from a medical doctor.


MVVM for EMs
Firstly let’s get the acronym out of the way. MVVM stands for model, view, view-model. It has a nice symmetry, but there are three components here and they all have separate responsibilities. The main purpose of MVVM is to keep business logic in a single place; the view model. All dependencies that are required to show something on the screen, to calculate something, all fall under the jurisdiction of the view-model. Let’s take a look at the responsibilities of each of the three components.
Model
This is the first M of MVVM. The model’s sole task, and it is a basic one, is simply to store data. There is no logic in the model, no network calls.  For instance you may place some JSON parsing in the model object, but no transformation will be done outside the realm of mapping.
{ "totalPrice": 30.99, "currencySymbol": "$", "currencyCode": "USD" }
View
The next component is the view, the next V in the MVVM acronym. This is simple. It’s the stuff you see on screen, or whatever the client will consume. In the case of of a mobile app, the view may be a button, a label, or even an entire login screen. For an API the V may be the JSON that gets sent out to the client.
There is no logic in the view. The view simply read values, or, in some cases, reacts to values, that get passed in. By the:
View model
I left this for last, but it is the VM in MVVM. This is where the meat and bones are. This is where all the logic, all the handling, all the updates, all the treatment gets done. The view model is the middleman between the view and the model. It’s job is to take ownership of all the business logic, view logic, server call logic. A view model takes in model objects, or other view models, and composes itself in a way that will set itself up to give a view what it needs. It will hand the view direct, hopefully, flat mapped properties for the view to read.
So what does it look like?
Real world example
Let’s take a real world example. Let’s say we want to present the user a total price for their holiday. This will involve:
- A network call
- A place to store the total cost amount
- Some beautification of the total cost amount
- A view to present the user the total amount
We’ll now break it down using some swift to showcase how this all looks then talk about the lifecycle.
The model
You can ignore the init method in the example below. This is just an example that parsing and mapping concerns can lay with the model object. The example parses in a JSON object and stores the totalPrice from that object, storing it into price on TripPrice. This is not a view concern, logic or formatting outside of marshaling data presented from the server into the model object. Really, if you’re doing your API layer correctly for a client <-> server relationship, this really should be flat mapped and one to one easily parsed.
struct TripPrice {
let price: Double
init?(jsonResult:Any) {
guard let result = jsonResult as? [String: Double],
let price = result["totalPrice"] else {
return nil
}
self.price = price
}
}
The view
Here you can see we need to initialize our PriceLabel object with a TripPriceViewModel. When we do we call the internal method of updateView, which will read the property totalPriceText and set it on the text. Long story short, make a new label and give it a view model, it will automatically update that label’s text with the totalPriceText from that view model.
There is a binding mechanism here also. So after a tripPrice is fetched, the view model will report back with the text that the view should update itself to. This binding is viewModel.tripUpdatedCallback = { text in
and is a simple example of a callback.
class PriceLabel : UILabel {
let viewModel: TripPriceViewModel
init(viewModel: TripPriceViewModel) {
self.viewModel = viewModel
viewModel.tripUpdatedCallback = { text in
self.text = text
}
updateView()
}
func updateView() {
self.text = viewModel.totalPriceText
}
}
The main thing to pay attention to here is the setting of the viewModel, and the updateView method and what that does.
The view model
The view model now does all the logic for us. You can see there is some handling done in order to calculate the totalPriceText
. This first checks if we have a price value, if we don’t we report back that we’re fetching total price otherwise we stitch together some pricing text.
fetchResults
is the otherside of the coin for that binding to the view. We do some network calls out to the webservice to get our tripPrice. We then make a TripPrice object and then use the callback to report the updated text, which should be formatted if we have a properly formatted TripPrice.
class TripPriceViewModel {
private var tripPrice: TripPrice?
var tripUpdatedCallback: ((String) -> Void)?
var totalPriceText: String {
guard let price = tripPrice?.price else {
return "Fetching total price"
}
return "The total trip price is $\(price)"
}
init(tripPrice: TripPrice) {
self.tripPrice = tripPrice
fetchResults()
}
func fetchResults() {
//Fetch some JSON and return it
tripPrice = TripPrice(json)
tripUpdatedCallback?(totalPriceText)
}
}
Stitching it all together
So what does this all mean? Let’s talk about how this all would play in together. Part of our view layer would also be a ViewController. A view controller is quite standard and you would be familiar with it in the MVC world. It’s part of the view lifecycle for a Mobile App, a presenter, a VC.
There is minimal logic in the VC as you can see below. Instead it is mainly just used to marshall previous ViewModel objects and handle data flow to place onto view objects etc. There is no logic here outside of the life cycle of a viewController (loading and setting up views).
class TripPriceViewController : UIViewController {
let tripPriceViewModel: TripPriceViewModel
var totalPriceLabel: PriceLabel
init(vm: TripPriceViewModel) {
self.tripPriceViewModel = vm
self.totalPriceLabel = PriceLabel(viewModel: vm)
}
}
Reactive functional programming & MVVM
There is another mechanism for views to be made aware that they need to redraw, thats in the form of signals with reactive functional programming (RFP). Look up reactive functional programming if you would like to see this concept applied to MVVM. In short, there’s a constant stream of signals being sent from the view models. The views subscribe to these signals, much like a FM radio, constantly listening. If the view hears something that interests them, like say “Hide Checkout Button” then the view will pick that value up and set its checkout button to hidden. The MVVM never hold view logic, as in, it doesn’t know what element to hide, nor what property its values are getting set on. It simply holds state and the logic of that state.
So when the view gets a signal “Hide Checkout Button”, in the view model you will see something like:
self.checkoutButtonShouldBeVisible = false
but then in the view:
if self.checkoutButtonShouldBeVisible == false {
self.checkoutButton.hidden = true
}
Benefits of MVVM
Modular is better
As you can see the view model is very modular. You pass in dependencies that it needs. Functions of the view model are broken down per responsibility and have minimal mutation on the object. This means testing becomes a breeze and is MVVM’s biggest win for me. You’re set up for dependency injection, meaning, you can pass in all the objects and their values without having to set up the view hierarchy, set up viewControllers etc. You’re then able to mock all the objects you like and build test coverage on a myriad of scenarios, all whilst testing the view model only.
RFP
When RFP is thrown into the mix, MVVM comes into its own. The ability for a view to react to the change of a properties state automatically is powerful. RFP comes with its own challenges though, and for that I don’t use it on the iOS platform (debugging is/was hell). Binding VM property state to properties on views allows direct mapping of state to view side effects. It’s powerful, but with great power, comes great debugging. Be warned, you can go overboard with signals and RFP.
Maintainability
No longer is your logic spread over multiple files for a particular screen. You can easily narrow in on a particular area of your app and know (hopefully) that all of its associated logic is in its counterpart ViewModel file. Having logic in a centralized place for a particular concern is a big win for maintainability.