Session with Qi Lu
This article was first written on May 13, 2016. With Qi’s departure from Microsoft, I found it refreshing to revisit the session with him, and find renewed inspirations from him. Good luck Qi in your future endeavor.
As part of my COS448 experience we were very fortunate to have Qi Lu from Microsoft calling today for a casual fireside chat. Below is some takeaways I jotted down.
1. What are the three most useful things that you learned from this guest speaker or session that you didn’t know before, or that you hadn’t thought about much before, and that you think you are likely to carry with you going forward?
The first thing I learned is Qi’s view on innovation, “product is the core, technology is the foundation, business is the make-or-break” — it’s only by intersecting the three inter-related areas together, finding the common denominator among human desirability, technology feasibility and business viability, that we can find a sustainable product that is wanted by consumers and profitable. All business ventures and product developments need to focus on testing these three areas before coming to any conclusions.
Secondly, I learned that in the life cycle of innovation, Qi thinks that the most difficult challenge lies in “Go-to-Market”: it’s vital for business to expose the product to the maximum right audience at the right time as fast as possible, and there is as much technicality, expertise and complexity as luck in its success.
Thirdly, I found the stories he shared, both about Yahoo and Microsoft, very interesting and enlightening. Especially on the browser war, I didn’t even think deep enough about the essence of our online experience, and Qi teased out his take as the experience is closely tied to search (which dictates discovery, access and interaction processes). As I’m developing apps for this class and thinking about mobile options, it’s imperative that I understand what WWW really means to users.
2. What surprised you most?
It surprised me a lot when Qi said Microsoft had won the browser war by having a superior product Internet Explorer (because of its expandability and compatibility), and I, being a millennial, was like “when did this happen?” I guess Microsoft had won the war in the sense that it defeated Netscape in market share — yet the victory was brief, and no one today would certainly regard IE as a good product (even Microsoft itself, since it has publicized Edge, an IE replacement, a great deal).
3. What did you like most about the speaker or the session?
Qi’s insight and organization (as seen from his slides) impressed me a lot — and his observation of the industry resonated with me and taught me a great deal. What do you think of Microsoft? It’s gotten so big that I struggle to find a single adjective to sum up my impression of Microsoft; yet it’s amazing how Microsoft seems to have reinvented itself and remained relevant for so long.


Now that we have seen all the elements of the compiler, let us examine an example of compiled code to see how things fit together. We will compile the definition of a recursive factorial function by calling compile:
We have specified that the value of the define expression should be placed in the val register. We don't care what the compiled code does after executing the define, so our choice of next as the linkage descriptor is arbitrary.
Compile determines that the expression is a definition, so it calls compile_definition to compile code to compute the value to be assigned (targeted to val), followed by code to install the definition, followed by code to put the value of the define (which is the symbol ok) into the target register, followed finally by the linkage code. Env is preserved around the computation of the value, because it is needed in order to install the definition. Because the linkage is next, there is no linkage code in this case. The skeleton of the compiled code is thus $\langle \textit{save}$ env $\textit{if modified by code to compute value}\rangle$ $\langle \textit{compilation of definition value, target}$ val$, \textit{linkage}$ next$\rangle$ $\langle \textit{restore}$ env $\textit{if saved above}\rangle$ perform( op("define_variable"), constant("factorial"), reg("val"), reg("env")); assign("val", constant(ok));
The expression that is to be compiled to produce the value for the variable factorial is a lambda expression whose value is the function that computes factorials. Compile handles this by calling compile_lambda, which compiles the function body, labels it as a new entry point, and generates the instruction that will combine the function body at the new entry point with the run-time environment and assign the result to val. The sequence then skips around the compiled function code, which is inserted at this point. The function code itself begins by extending the function's definition environment by a frame that binds the formal parameter n to the function argument. Then comes the actual function body. Since this code for the value of the variable doesn't modify the env register, the optional save and restore shown above aren't generated. (The function code at entry2 isn't executed at this point, so its use of env is irrelevant.) Therefore, the skeleton for the compiled code becomes assign("val", list(op("make_compiled_function"), label(entry2), reg("env"))), go_to(label("after_lambda1")), "entry2", assign("env", list(op("compiled_function_env"), reg("fun"))), assign("env", list(op("extend_environment"), constant(n), reg("argl"), reg("env"))), $\langle \textit{compilation of procedure body} \rangle$ "after_lambda1", perform(op("define-variable"), constant("factorial"), reg("val"), reg("env")), assign("val", constant(ok)),
A function body is always compiled (by compile_lambda_body) as a sequence with target val and linkage return. The sequence in this case consists of a single if expression:
Compile_if generates code that first computes the predicate (targeted to val), then checks the result and branches around the true branch if the predicate is false. Env and continue are preserved around the predicate code, since they may be needed for the rest of the if expression. Since the if expression is the final expression (and only expression) in the sequence making up the function body, its target is val and its linkage is return, so the true and false branches are both compiled with target val and linkage return. (That is, the value of the conditional, which is the value computed by either of its branches, is the value of the function.) $\langle \textit{save}$ continue$,$ env $\textit{if modified by predicate and needed by branches} \rangle$ $\langle \textit{compilation of predicate, target}$ val$, \textit{linkage}$ next$\rangle$ $\langle \textit{restore}$ continue$,$ env $\textit{if saved above}\rangle$ test(op("false"), reg("val")), branch(label("false_branch4")), "true_branch5", $\langle \textit{compilation of true branch, target}$ val$, \textit{linkage}$ return$\rangle$ "false_branch4", $\langle \textit{compilation of false branch, target}$ val$, \textit{linkage}$ return$\rangle$ "after_if3",
The predicate n === 1 is a function call. This looks up the operator (the symbol =) and places this value in fun. It then assembles the arguments 1 and the value of n into argl. Then it tests whether fun contains a primitive or a compound function, and dispatches to a primitive branch or a compound branch accordingly. Both branches resume at the after_call label. The requirements to preserve registers around the evaluation of the operator and operands don't result in any saving of registers, because in this case those evaluations don't modify the registers in question.
The code for the false branch is another a function call, where the function is the value of the symbol *, and the arguments are n and the result of another function call (a call to factorial). Each of these calls sets up fun and argl and its own primitive and compound branches. Figure \ref{fig:comp-factorial1} shows the complete compilation of the definition of the factorial function. Notice that the possible save and restore of continue and env around the predicate, shown above, are in fact generated, because these registers are modified by the function call in the predicate and needed for the function call and the return linkage in the branches.
n ? product : iter(product * counter, counter + 1); } \end{JavaScriptClickable} \end{lrbox} \begin{JavaScriptClickable} /*!\href{https://sourceacademy.nus.edu.sg/playground#chap=5&prgrm=GYVwdgxgLglg9mABMAhtOAnGKA2AKMASkQG8AoRS5caeJGKAUwzwAcM4ATEaAGkQhxwTDMXJUJiDIyggMSQcOaIAfIjAVJWgPyJ2XHlE1aJALkQNmbDt2iIAVAKFgR-RS+UBqRAEZCAbmNEAF8yIOlZeQsRPB9+P0DgoA}{\usebox\lstbox}!*/ return iter(1, 1); } \end{JavaScriptClickable}


Build Robust & Production Quality Applications - Lesson 1: Git Flow
26 Jan 2015How to create a branch and checkout at the same time:
git checkout -b mod3
- Anything in the master branch is deployable
- To work on something new, create a descriptively named branch off of master (ie: new-oauth2-scopes)
- Commit to that branch locally and regularly push your work to the same named branch on the server
- When you need feedback or help, or you think the branch is ready for merging, open a pull request
- After someone else has reviewed and signed off on the feature, you can merge it into master
- Once it is merged and pushed to ‘master’, you can and should deploy immediately
Read more: A successful Git branching model


--- sort_order: 5 tei_id: rdx_vkscx.p.idm140051185822176 annotation_count: 3 images: small-thumbnail: https://readux.ecds.emory.edu/books/readux:vks67/pages/readux:vkscx/mini-thumbnail/ json: https://readux.ecds.emory.edu/books/readux:vks67/pages/readux:vkscx/info/ full: https://readux.ecds.emory.edu/books/readux:vks67/pages/readux:vkscx/fs/ page: https://readux.ecds.emory.edu/books/readux:vks67/pages/readux:vkscx/single-page/ thumbnail: https://readux.ecds.emory.edu/books/readux:vks67/pages/readux:vkscx/thumbnail/ title: Page 5 number: 5 ---


Semantic gives you a variety of UI components with real-time debug output, letting your code tell you what its doing.
@(title:String)(design:String)(content:Html)
Semantic provides tracing for javascript behavior so your components can tell you what they're doing as they do it.
Learn about modules


Loading...
authChat
×
×
×
×
Login with Google to send and receive messages
{{ message.user }}:
{{ message.text }}
{{ downloadImages(message.imageHash) }}
user
Super-powered by Thiago Bonfim ©2017
×
Imagem


endog
, exog
, what’s that?¶
Statsmodels is using endog
and exog
as names for the data, the
observed variables that are used in an estimation problem. Other names that
are often used in different statistical packages or text books are, for
example,
endog |
exog |
|---|---|
y |
x |
y variable |
x variable |
left hand side (LHS) |
right hand side (RHS) |
dependent variable |
independent variable |
regressand |
regressors |
outcome |
design |
response variable |
explanatory variable |
The usage is quite often domain and model specific; however, we have chosen to use endog and exog almost exclusively. A mnenomic hint to keep the two terms apart is that exogenous has an “x”, as in x-variable, in it’s name.
x and y are one letter names that are sometimes used for temporary
variables and are not informative in itself. To avoid one letter names we
decided to use descriptive names and settled on endog
and exog
.
Since this has been criticized, this might change in future.
Background¶
Some informal definitions of the terms are
endogenous: caused by factors within the system
exogenous: caused by factors outside the system
Endogenous variables designates variables in an economic/econometric model that are explained, or predicted, by that model. http://stats.oecd.org/glossary/detail.asp?ID=794
Exogenous variables designates variables that appear in an economic/econometric model, but are not explained by that model (i.e. they are taken as given by the model). http://stats.oecd.org/glossary/detail.asp?ID=890
In econometrics and statistics the terms are defined more formally, and different definitions of exogeneity (weak, strong, strict) are used depending on the model. The usage in statsmodels as variable names cannot always be interpreted in a formal sense, but tries to follow the same principle.
In the simplest form, a model relates an observed variable, y, to another set of variables, x, in some linear or nonlinear form
y = f(x, beta) + noise
y = x * beta + noise
However, to have a statistical model we need additional assumptions on the properties of the explanatory variables, x, and the noise. One standard assumption for many basic models is that x is not correlated with the noise. In a more general definition, x being exogenous means that we do not have to consider how the explanatory variables in x were generated, whether by design or by random draws from some underlying distribution, when we want to estimate the effect or impact that x has on y, or test a hypothesis about this effect.
In other words, y is endogenous to our model, x is exogenous to our model for the estimation.
As an example, suppose you run an experiment and for the second session some subjects are not available anymore. Is the drop-out relevant for the conclusions you draw for the experiment? In other words, can we treat the drop-out decision as exogenous for our problem.
It is up to the user to know (or to consult a text book to find out) what the
underlying statistical assumptions for the models are. As an example, exog
in OLS
can have lagged dependent variables if the error or noise term is
independently distributed over time (or uncorrelated over time). However, if
the error terms are autocorrelated, then OLS does not have good statistical
properties (is inconsistent) and the correct model will be ARMAX.
statsmodels
has functions for regression diagnostics to test whether some of
the assumptions are justified or not.


| 196 | (A) | and alle gronande witħ gladnes grete god he thankede |
| (C) | ---- no text ---- | |
| 192 | (D) | And he gronyng glad þe grete god thankid |
| 190 | (E) | tho was his fadur wundur glad . & Iesu crist thanked |
| (Ex) | ---- no text ---- | |
| 195 | (L) | & he gronnand glad grete god þanked |
| 189 | (P) | And he was glad of þat grace & gretely he thanked |
| 190 | (U) | And he gronyng glad / the grete god thanked |
| (V) | ---- no text ---- |


30 great reader Christmas trees from Newcastle and the North East
Over 1000 readers shared photographs of their Christmas pride and joy and we picked 30 to feature here - and another 20 in our video!
09 Dec 2019, 16:18 by Lesley Oldfield
If you haven't got your Christmas tree sorted yet there are lots of great ideas in these photographs, whether you choose real or fake, colourful or monochrome, silver, gold or bright orange!
Inventive Kacie Ward shows that you can have a fun Christmas tree for 2019 no matter how small(Image: Newcastle Chronicle)
The upside down Christmas tree of readers Kathryn and Edd Stoddart(Image: Newcastle Chronicle)
This Christmas tree belonging to reader Michael Lockwood is surrounding by matching decoration(Image: Newcastle Chronicle)
Sarah Marsh's pretty Christmas tree for 2019(Image: Newcastle Chronicle)
A mini train set and lights around the 2019 Christmas tree submitted by reader Verity Sullivan(Image: Newcastle Chronicle)
The lovely big Christmas tree of reader Kevin English(Image: Newcastle Chronicle)
Amanda Jane McLoughlin's son loves their 2019 Christmas tree(Image: Newcastle Chronicle)
A huge, bauble-clad Christmas tree submitted by reader Rachael Robson(Image: Newcastle Chronicle)
Christmas tree 2019 submitted by reader Debbie Marie(Image: Newcastle Chronicle)
A silver-bright Christmas tree submitted by reader Nichola Thompson(Image: Newcastle Chronicle)
Boxes around the Christmas tree 2019 submitted by reader Donna Louise Stark(Image: Newcastle Chronicle)
The colourful 2019 Christmas tree of reader Charlie Bridon(Image: Newcastle Chronicle)
A candy cane tree Christmas tree 2019 submitted by reader Ashleigh Robinson, who made many of the decorations(Image: Newcastle Chronicle)
The distinctive 2019 Christmas tree of reader Jodie Freeman(Image: Newcastle Chronicle)
A silvery Christmas tree 2019 submitted by reader Ashley Dixon(Image: Newcastle Chronicle)
A Disney-themed Christmas tree for 2019 submitted by reader Lynn Quinn(Image: Newcastle Chronicle)
The busy and beautiful 2019 Christmas tree of reader Leanne Turner(Image: Newcastle Chronicle)
Bright lights swirl round Nicola Worsford's Christmas tree for 2019(Image: Newcastle Chronicle)
Can you spot the cat in reader Krystal Lapsley's 2019 Christmas tree?(Image: Newcastle Chronicle)
Mandy Hurst's dog gives the seal of approval to her Christmas tree for 2019(Image: Newcastle Chronicle)
An ususual dress-shaped Christmas tree 2019 submitted by reader Alison Gray(Image: Newcastle Chronicle)
Allyson Bolam's huge Christmas tree for 2019 is topped by a giant bow(Image: Newcastle Chronicle)
A snowy scene Christmas tree 2019 submitted by reader Catherine Iveson(Image: Newcastle Chronicle)
A huge, bauble-clad Christmas tree submitted by reader Rachael Robson(Image: Newcastle Chronicle)
Melanie Liversidge in Australia has a stylish Christmas tree for 2019(Image: Newcastle Chronicle)
It's not a Christmas tree but a great alternative, submitted by reader Sandra Roberts(Image: Newcastle Chronicle)
A snowman Christmas tree for 2019 submitted by reader June Bainbridge Pull(Image: Newcastle Chronicle)
Faye Savage and her daughters decorated this Christmas tree(Image: Newcastle Chronicle)
A colourful glow for reader Stephen Gott's 2019 Christmas tree(Image: Newcastle Chronicle)
Christmas tree 2019 submitted by reader Angela Nicholson(Image: Newcastle Chronicle)


EV Charging stations
Plan your trip
Starting Location
Add Current Location
Destination
Nearest Charge Point
Super Charge Point
Get directions


Geometric Modelling: 2016-2017
|
Lecturer |
|
|
Degrees |
|
|
Term |
Hilary Term 2017 (16 lectures) |
Overview
This is an introductory course in modelling techniques for 3D objects. It covers a wide range of different ways of representing the geometry of real objects, depending on their functionality and application. The emphasis in this course will be on the theory and basic principles of constructing models; hence the practicals will not use CAD-specific software, but rather a programming environment suitable for reasoning about the mathematics of models.Learning outcomes
At the end of the course, the student will:
- understand the need for, and the different applications of geometric modelling techniques
- understand some of the technical solutions
- be able to reason about the range of solutions to problems involving 3D objects
Prerequisites
Knowledge of basic matrix and vector algebra is assumed, as is basic set theory.The course does not deal with the rendering of such models: this is left to Computer Graphics. Neither does it deal with any of the applications once the models have been created: this is left to Computer Animation. Whilst there are obvious links between these three courses, they have been designed to be independent of each other.
Synopsis
- Point, line and line segment; relative positions; polyline [1]
- Polygon, convex and concave; polyhedron; convex hull [1]
- Different kinds of geometric modellers [1]
- Boundary representation modelling [1]
- Boundary representation operations [1]
- Constructive Solid Geometry introduction; interval arithmetic [1]
- Constructive Solid Geometry tree pruning; blends; integral properties [2]
- Splines introduction; Bézier curves [1]
- Drawing splines; degree elevation [2]
- Sculptured surface patches: applications [1]
- General splines; constructing splines from Bézier curves [1]
- B-splines; interpolation splines [1]
- Voronoi diagram; Delaunay triangulation [1]
- Largest empty circle; Voronoi diagram generalisation(s) [1]
Syllabus
- Point, line and line segment; relative positions; polyline
- Polygon, convex and concave; polyhedron; convex hull
- Different kinds of geometric modellers
- Boundary representation modelling
- Boundary representation operations
- GSG introduction; interval arithmetic
- GSG tree pruning; blends; integral properties
- Splines introduction; Bézier curves
- Drawing splines; degree elevation
- Sculptured surface patches: applications
- General splines; constructing splines from Bézier curves
- B-splines; interpolation splines
- Voronoi diagram; Delaunay triangulation
- Largest empty circle; Voronoi diagram generalisation(s)
Reading list
Unfortunately there is no single textbook that covers the syllabus. The following have been part of reading lists
for past courses and might be useful:
For B-rep modelling (all rather vague - ask me if you want to see a copy)
- Martti Mäntylä, Solid Modeling, Computer Science Press, 1988. (out of print)
- Hiroaki Chiyokura, Solid Modeling with Designbase, Addison-Wesley, 1988 (out of print)
- Ian Stroud, Boundary Representation Modelling Techniques, Springer Verlag, 2006
For CSG
- The svlis manual contains a very good introduction to CSG and related issues
- A J P Gomes, I Voiculescu, J Jorge, B Wyvill, C Galbraith, Implicit Curves and Surfaces: Mathematics, Data Structures and Algorithms, Springer 2009, ISBN 978-1-84882-405-8 (not compulsory)
- J R Woodwark, Blends in geometric modelling, in The Mathematics of Surfaces (R.R. Martin, ed.) (Proceedings of the 2nd IMA Conference on the Mathematics of Surfaces, Cardiff, 1986) (255--297), Oxford University Press, 1987
For parametric curves, splines and NURBS
- E Cohen, R Riesenfeld, G Elber, Geometric Modelling with Splines: an intr oduction, A K Peters 2001. (thorough, but theoretical)
- Les Piegl, Wayne Tiller, The NURBS Book, Springer 1997. (B-splines and NURBS)
- G Farin, Curves and surfaces for computer aided geometric design, Academic Press, 1990. (practical applications)
For positions of points, lines and segments, also for convex hull and Voronoi diagrams:
- O'Rourke, J Computational Geometry in C, Cambridge University Press, 1994. (classic in computational geometry)
For a summary of various topics:
- J D Foley, A Van Dam, S K Feiner, J F Hughes and R L Phillips, Introduction to Computer Graphics, Addison-Wesley 1996. (chapters on B-rep and CSG, also rigid body transforms)
- T H Cormen, C E Leiserson and R L Rivest, Introduction to Algorithms, MIT Press, 1990. (general algorithms and complexity)


Delete Account
the deletion of your account will results in the loss of every item you have, and all friendships will be lost


First, have you read the NetCourse Basics? You should have. If not, click here to read them now.
Second, we wish to emphasize that all will go better if you participate, which you do by posting messages to the NetCourse 152 message board. When you post messages, all participants can see your message.
When asking questions about the lectures, please refer to the section heading of that portion of the lecture. Section headings look like this:
All right, with that out of the way, we begin ...
This is not so much Lecture 1 of NC-152 as it is Lecture 5 of NC-151, so as a way of getting back into it, let's review where we are:
program
can be used interactively but seldom is,
except for pedagogic purposes.program
can be used within a do-file and often is.
Such do-file programs are typically intended for a special purpose, and the
do-file contains not only the program or programs but also the (sequential)
code that uses these temporarily created commands.program
can be used within an ado-file, which is
nothing more than a do-file that Stata automatically loads when necessary.
Such automatic do-files contain only the program definition. In this way, you
can add new commands to Stata for use in any context.`1',`2', ...; `1'
contains the first thing
typed after the command name,
`2'
the second, and so on.i
used as a loop counter, we call it what it
is—a macro or scalar. We do not call it a variable.tempvar
(for variables),
tempname
(for scalars and matrices), and
tempfile
(for files); this was only touched on in
NC-151.preserve
, lets you temporarily
destroy the data in memory if necessary. When the program completes, the data
are automatically restored. The data can also be restored manually using the
restore
command.if
and else
command for branching.foreach
is useful for looping across a list of variables or file names.forvalues
can be used to cycle through a list of numbers.while
can be used to execute commands until a
certain condition is met.
You can use forvalues
and while
to loop across observations, but
they are slow; in most situations, you should use explicit indexing along with
the by varlist:
prefix
version
command that you can use to declare which
version you used to write the program so that it will continue to work in later
releases of Stata.
This course is really about item number 16, although along the way we will pick
up more pieces of Stata syntax. For instance, we did not cover all the
capabilities of syntax
. We will.
Here's a simple program that we left off with in NC-151:
| ADO-FILE: iqr.ado |
|---|
|
Do you remember what iqr
does?
. iqr mpg
mpg obs = 74 median = 20 iqr = 7. iqr mpg weight
mpg obs = 74 median = 20 iqr = 7 weight obs = 74 median = 3190 iqr = 1360. iqr mpg weight if foreign
mpg obs = 22 median = 24.5 iqr = 7 weight obs = 22 median = 2180 iqr = 630
iqr
reports the median and interquartile range. It
allows a varlist but does not require it (in which case it reports results for
all the variables in the data), and iqr
optionally
allows an if exp
.
Inside iqr
, the first line is concerned only with
parsing the user's request:
syntax [varlist] [if]
The rest of the code loops across the variables, invokes
summarize
repeatedly, and reports the results:
foreach i of local varlist {
quietly summarize `i' `if', detail
display ///
"`i'" ///
_col(20) "obs = " r(N) ///
_col(30) "median = " r(p50) ///
_col(51) "iqr = " r(p75)-r(p25)
}
As a reminder, let's run back over the parsing step, but this time, let me show you exactly what is happening.
Pretend that the user types
. iqr mpg wei if foreign
When the program begins to execute, before the first line of
iqr
code has been executed, the macros and their
values are
| `0' | `1' | `2' | `3' | `4' | `varlist' | `if' |
|---|---|---|---|---|---|---|
| mpg wei if foreign | mpg | wei | if | foreign |
Note that the macros `varlist'
and
`if'
have not been defined yet, so they are blank.
Stata passes what the user types to the program in two ways:
`0'
, Stata puts exactly what the user typed as the user typed it.`1', `2'
, ..., Stata puts what the
user typed, broken into "words", where words are defined as "separated by
blanks or spaces".Pretend that the user typed
. iqr mpg wei if foreign
(note the two blanks between wei andif
)
The `0', `1',
... macros would contain
| `0' | `1' | `2' | `3' | `4' |
|---|---|---|---|---|
| mpg wei if foreign | mpg | wei | if | foreign |
That is, `0'
would change because it is a perfect copy
of what the user typed. Macros `1'
,
`2'
, `3'
, and
`4'
would not change because the words still break
the same way.
Now, our iqr
program comes to executing the first
line:
syntax [varlist] [if]
syntax
does not care what is in
`1',`2',
....
syntax
cares only about what is in
`0'
.
syntax
parses what the
user typed only because `0'
automatically contains
what the user typed. In other words, if we changed the contents of
`0'
before issuing syntax
,
syntax
would look at the changed contents of
`0'
.
Here is the result of syntax [varlist] [if]
:
|
||||||||||
|
|
(macros `0', `1', ... remain unchanged)
|
|||||||||
syntax [varlist] [if]
reads `0' and fills
in `varlist' and
`if'
|
<--- syntax
just knows to read `0'
|
|||||||||
|
|
||||||||||
|
The parsing is now complete: we have the unabbreviated variable names in
`varlist'
and the if condition in
`if'
.
Next comes the foreach
list processor, the important
part of which reads
foreach i of local varlist {
...
}
So much for review.
We were discussing the syntax
command when we left off
on NC-151, so let's complete that discussion. Here is what happens when a user
types a command:
`0' and `*' are set to
contain the command arguments exactly as typed |
||||||
|---|---|---|---|---|---|---|
| . command | thing1 | thing2 | thingk |
`k+1'
set to contain (nothing)
|
||
`k'
set to contain thingk |
||||||
`2' set to contain
thing2 |
||||||
`1' set to contain
thing1 |
||||||
| Stata executes command.ado |
Stata passes thing1 thing2 ... thingk to you in the following ways:
`0'
.`1'
, the second
word as `2'
, and so on.`*'
.
You may choose to parse the line based on any one or all three of these conventions, although usually, you use just 1 or 2.
Method 2, the `1', `2', `3'
... convention, also known
as the argument convention, is sometimes adequate. I find that it is adequate
when I am writing subroutines, which are "commands" that are not intended to be
used directly by the user but that help my main program along.
For the main program, however, I typically want Stata syntax, and that is easy
to arrange using syntax
because
syntax
uses `0'
.
The generic Stata syntax is
. command varlist weight =exp if exp in range using filename, options
syntax
provides specifiers that you can place on the
syntax
line to indicate which pieces of Standard Stata
Syntax you intend to allow:
| Syntax piece | syntax specifier |
Result returned in |
|---|---|---|
| varlist | varlist
varname
newvarlist
newvarname
|
`varlist'
`varlist'
`varlist' and `typlist'
`varlist' and `typlist'
|
| weight | fw , pw , aw , iw |
`weight' and `exp' |
| =exp | =exp |
`exp' |
| if exp | if |
`if' |
| in range | in |
`in' |
| using filename | using |
`using' |
| options | (we will come to that) | (macro of same name as opt) |
| Examples: | ||
|
Note:
syntax
line, you are stating that the element is not
allowed.
In our little iqr
command, we started things off with
syntax [varlist] [if]
So, a varlist was optional and, if the user specified it, was stored in the
macro `varlist'
. The definition of varlist says that,
if the user does not specify a varlist, `varlist'
is
filled in with every variable in the dataset. If we wanted the default
behavior to be that `varlist'
is filled in with
nothing, we would specify
syntax [varlist(default=none)] [if]
.
See help syntax
for the details.
According to our syntax
statement,
if exp
is also optional. If the user
specifies an if exp
,
it is stored in
`if'
; if the user does not,
`if'
is filled in with nothing.
if
, unlike
varlist
, defaults to nothing; see
help syntax
.
According to our syntax
statement, no other elements
of Stata syntax are allowed.
So,
if the user typed iqr weight mpg if foreign
after the
syntax
,
`varlist' contains weight mpg
`if'
contains if foreign
if the user typed iqr weight mpg
after the
syntax
,
`varlist'
contains weight mpg
`if'
contains ""
if the user typed iqr wei mpg
after the
syntax
,
`varlist'
contains weight mpg
`if'
contains ""
if the user typed iqr
after the
syntax
,
`varlist'
contains every variable in the dataset
`if'
contains ""
if the user typed
iqr weight mpg if foreign in 1/10
,
syntax
would issue the error
in not allowed
and stop the program
So, syntax
really is easy: you define what you are
willing to tolerate and find the pieces in the macros of the same name.
There are lots of little details that will help you obtain exactly what you
want, and the best way to learn about them is to type
help syntax
. Here, for instance, is a little bit of
what help syntax
has to say about the
varlist specifier:
description_of_varlist Type nothing or optionally type |
help syntax
really is worth reading.
Let's think about how we would parse some common Stata commands if we were rewriting them:
| Command | Syntax | Parsing code |
|---|---|---|
summarize |
summarize [varlist] [weight] [if exp] [in range] where aweights and fweights are allowed |
syntax [varlist] [aw fw] [if] [in] |
generate |
generate [type] newvar = exp [if exp] [in range] | syntax newvarname =exp [if] [in] |
tabulate |
tabulate varname [varname] [weight] [if exp] [in range] where fweights are allowed |
syntax varlist(max=2) [fw] [if] [in] |
regress |
regress depvar [indepvars] [weight] [if exp] [in range] where aweights, fweights, and iweights are allowed |
syntax varlist [aw fw iw] [if] [in] |
Note: when you specify newvarname or newvarlist,
syntax
stores the corresponding types of the
variables in `typlist'
and the variable names in
`varlist'
.
Options work a lot like the other pieces of Stata syntax. You specify the
option inside or outside square brackets on the syntax
statement, and you get back the value of the option in a local macro of the
same name.
Say that I want to create a command that has the option
detail
. I might code
syntax [varlist] [if] [in] [, detail]
The result of this will be that syntax
will fill in a
macro named `detail'
, which will contain nothing if
the user did not specify the detail
option. If the
user did specify the option, it will contain the word detail
. That is,
after parsing, macro`detail'
contains "" ordetail
.
That is a general rule. Say I wanted also to allow option
beta
:
syntax [varlist] [if] [in] [, detail beta]
or
syntax [varlist] [if] [in], [ beta detail]
(the order does not matter). Then, after parsing,
macro`detail'
contains "" or "detail"
macro`beta'
contains "" or "beta"
In general,
macro `whatever'
contains "" or "whatever"
Macro whatever contains "whatever" if the user specified the whatever option, and it contains nothing otherwise.
Putting "whatever" into
`whatever'
may seem a
repetitive way to specify the option, but it turns out to be useful.
Imagine that the reason you are allowing the detail
option is that you will, later in your program, pass it along to the
summarize
command. You can later code
summarize ... , `detail'
If the user specified the detail
option,
`detail'
contains detail
,
so the command reads
summarize ... , detail
If the user did not specify the option, the command reads
summarize ... ,
which is okay with Stata (Stata does not mind the hanging comma). In other cases, you may need to take a different path through your code, depending on the option, and you will code this as
if "`beta'"!="" {
/* special code for option beta specified */}
or
if "`beta'"=="" {
/* special code for option beta not specified */}
When you declare option(s),
syntax [varlist] [if] [in] [, detail beta]
you can specify the minimum abbreviation by capitalizing it:
syntax [varlist] [if] [in] [, DEtail BETa]
This allows the user to abbreviate detail
as
de
and beta
as
bet
.
Sometimes, I want options that work backwards. Instead of
detail
being the option and
nodetail
being the default, I want
nodetail
to be the option and
detail
to be the default:
syntax [varlist] [if] [in] [, noDEtail BETa]
The result of the parsing will still be to record the result of the
nodetail/detail choice in local macro `detail'
, but
now, `detail'
will contain "" if no option is
specified and nodetail
if nodetail
is specified. That's consistent if you think about it.
Aside:
Think of options as detail/nodetail, and not just detail or nodetail. In the
example above,
If we declare nothing, and
If we declare nothing, and |
In addition to switches such as detail/nodetail, options sometimes need
arguments. syntax
allows eight kinds of arguments:
syntax [varlist] [if] [in] [, ///
one(integer 1) two(real 3.14) three(string) ///
four(varlist) five(numlist) six(passthru) ///
seven(namelist) eight(cilevel)
In this declaration, the new command being created allows eight
options—one(), two(), three(), four(), five(), six(),
seven(), and eight
—each option having a specific type.
Option one()
, specified as
one(integer 1)
, is declared to require an integer
argument. If the user does not specify the option, the value 1 is assumed.
Thus syntax
will create a macro
`one'
, which will contain 1
if the user
does not specify the option, or contain whatever integer the user did specify.
syntax
will ensure that, if the user specified the
option, the user specified an integer; if the user types, say,
one(1.2)
, syntax
produces an
error, and everything stops.
Option two()
, declared
two(real 3.14)
, is much like option
one()
, except that it allows a floating-point
argument and defaults to 3.14 if two()
is not
specified. Thus, as long as the user enters a number or nothing at all, macro
`two'
will be created, containing the floating-point
number specified or 3.14
.
Option three()
, declared
three(string)
, allows a string argument—meaning
that it can be anything. Whatever the user types inside the parentheses will
be copied to a macro named `three'
. If the user types
nothing, macro `three'
will contain ""
.
Option four()
, declared
four(varlist)
, allows a varlist argument.
Whatever the user types will be interpreted as a varlist, the abbreviations
and shorthands will be expanded, and the result will be stored in macro
`four'
. If the user types nothing, macro
`four'
will contain ""
.
Option five()
, declared
five(numlist)
, allows a numlist argument, which is a
fancy list of numbers; see help numlist
. Whatever the
user types will be interpreted as a numlist, expanded, and stored in macro
`five'
.
Option six()
, declared
six(passthru)
, is a variation on the option coded
three(string)
, the difference being that passthrough
options include the option name and a parenthesis-bound argument. As with all
options, the macro `six'
will be created or not
depending on whether the user -specified option
six()
. In this case, if the user does specify option
six()
, macro `six'
will
contain six( exactly what the user typed)
.
Option seven()
, declared
seven(namelist)
, is similar to option
four()
. However, unlike varlist, namelist is the
appropriate way to obtain a user specified list of just about anything other
than existing variables. This could include e.g., a list of matrices, new
variables. Whatever names the user types will be stored in the macro
`seven'
. If the user types nothing, macro
`seven'
will contain ""
.
Option eight()
, declared
eight(cilevel)
, is declared to require a valid level
for a confidence interval. Valid levels are between 10 and 99.99 with at most
two digits after the decimal point. If the user types, for example,
eight(5)
or eight(35.654)
,
syntax
produces an error, and everything stops:
There is an ninth kind of option. If you specify an asterisk (
*
) on the syntax
command,
syntax [varlist] [if] [in] [, ///
one(integer 1) two(real 3.14) three(string) ///
four(varlist) five(numlist) six(passthru) ///
seven(namelist) eight(cilevel) *
^^^
whatever other options the user types will be allowed and placed into a local
macro `options'
. For instance,
syntax [varlist] [if] [in] [, Detail *]
would allow the detail
option (abbreviation
d
), and that option would be put into
`detail'
, but any other options the user typed would
not be considered an error. Say the user typed
. mycmd ..., detail saving(mygph, replace)
After the parsing, `detail'
would contain
detail
, and `options'
would contain
saving(mygph, replace)
. If the user typed
. mycmd ..., saving(mygph, replace)
`detail'
would contain nothing, but
`options'
would still contain
saving(mygph, replace)
. If the user typed
. mycmd ..., detail
`detail'
would contain detail
, and
`options'
would contain ""
.
With *
, the user can specify no extra options, one
extra option, or many extra options. For example,
. mycmd ..., detail border saving(mygph, replace)
would put detail
in `detail'
and
border saving(mygph, replace)
in
`options'
.
This is especially useful for creating commands where you wish to allow all
options of some other command because, later in your code, you will be
executing that other command. For instance, say that
mycmd
is going to draw a graph and that, in addition
to the detail
option, you want to allow all the
options of the scatter
command. One way would be to
create a long syntax
command specifying the options
syntax [varlist] [if] [in] [, ///
Detail Msymbol(passthru) Connect(passthru) SAVing(passthru) ...]
and then later in your code including all the options explicitly:
scatter ..., `msymbol' `connect' `saving' ...
It is easier to code
syntax [varlist] [if] [in] [, Detail *]
and then, later, code
scatter ..., `options'
This leaves scatter
to issue proper error messages if
anything in `options'
is invalid for the
scatter
command. An added benefit is that, if new
options are added to the scatter
command in the
future, your command automatically inherits these new options without your
having to change your code.
As an example of a complicated parsing problem, let's pretend we were rewriting
Stata's ttest
command, which has three syntaxes:
(1)ttest varname == # [if exp] [in range]
(2)ttest varname1 == varname2 [if exp] [in range]
(3)ttest varname [if exp] [in range], by(groupvar) [unequal welch]
The first syntax is for testing the mean of a variable against a constant, the second for testing the equality of means of two variables in matched data, and the third for testing the equality of means between two groups in unmatched data. Corresponding to these three syntaxes are three different statistical procedures that we want to carry forth.
The way to attack this problem is to write three different commands:
tt_1 varname = # [if exp] [in range]
tt_2 varname1 = varname2 [if exp] [in range]
tt_3 varname [if exp] [in range], by(groupvar) [unequal welch]
Each of those commands would be pretty easy to write, so let's pretend we have
written them and stored them in tt_1.ado
,
tt_2.ado
, and tt_3.ado
.
Technical Note: Using == or = in the syntax of the command
In Stata 9, the syntax for |
I start working on a problem from the top down: I do not write
tt_1.ado
,
tt_2.ado
, tt_3.ado
yet because I might decide to change the design
as I write the top. Right now, I know merely that I could write three such
programs, and if all turns out as I plan, I will eventually write them.
Right now, my problem is to write ttest.ado
, assuming
the existence of tt_1
, tt_2
,
and tt_3
. A merged syntax diagram for
ttest
, written generically, is
ttest varname [=exp] [if exp] [in range] [, by(groupvar) unequal welch ]
and corresponding to this syntax diagram are rules. If you specify
=exp
, it must be a number or a variable name,
and by(groupvar)
cannot be specified, and so on. I'll
worry about these rules later. To generically parse the command, the code is
syntax varname [=exp] [if] [in] [, BY(varlist) UNEqual Welch ]
Aside: In many older Stata programs, you will see the line
following
In this program, however, there is no distinction between the list and the individual names because we know the list contains exactly one variable name. We know that because we declared
at the outset. Therefore, we can to refer to the single variable as
Before Stata 7, the |
Once the syntax
parsing is out of the way, I can begin
to think about the three syntaxes in particular. For instance, my code might
continue with
if "`exp'"=="" {
/* it must be the syntax 3 case */}
else {
/* it is syntax 1 or syntax 2 */}
To determine if what the user typed corresponds to syntax 1 or 2, I need to
look at the contents of `exp'
to see whether it is a
number or a variable name. As I have set things up,
`exp'
contains =whatever
,
but I want to look at just the whatever portion.
I could write code to strip the leading equals sign, or I could go back and
change my parsing setup to tell Stata to leave off the equals sign when
storing the =exp. The second is easier, so my
parsing step becomes
syntax varname [=/exp] [if] [in] [, BY(varlist) UNEqual Welch ]
^
Note that I insert a forward slash.
After the syntax
, if `exp'
contains something, it does not contain the leading equals sign. So, now the
code following the syntax
could read
if "`exp'"=="" {
/* it must be the syntax 3 case */}
else {
/* it is syntax 1 or syntax 2 */capture confirm number `exp'
if _rc==0 {
/* it is syntax 1 */}
else {
/* it is syntax 2 */}
}
capture
we covered in NC-151. It captures any output
and error codes produced by the command it precedes. After
capture
, we can look at _rc
to see how things went. confirm
was not discussed in
151. I'll let you learn all the details of confirm
on
your own—type help confirm
in Stata—but it is pretty easy.
. confirm number anything
looks at anything and determines if it could be
interpreted as a number. If it can, confirm
does
nothing. If not, confirm
issues the appropriate error
message and nonzero return code. Try it interactively:
. confirm number 5
. confirm number -2.5
. confirm number mpg
'mpg' found where number expected r(7);. confirm number
'' found where number expected r(7);
With a capture
in front of the
confirm
, the error message is suppressed, but if we
examine the return code, _rc
, we will find out
whether what follows the confirm number
can be
interpreted as a number. In the case of our program outline,
confirm number `exp'
will set
_rc
to 0 if `exp'
is a number and to something else (7, actually, but who cares?) if
`exp'
is not a number.
Thus, assuming the existence of tt_1.ado
,
tt_2.ado
, and tt_3.ado
, our
ttest.ado
file could read
program ttest
syntax varname [=/exp] [if] [in] [, BY(varlist) UNEqual Welch ]
if "`exp'"=="" {
tt_3 `0'
}
else {
capture confirm number `exp'
if _rc==0 {
tt_1 `0'
}
else {
tt_2 `0'
}
}
end
Note the way `0'
is being passed along to the
subprogram. We parsed `0'
using
syntax
to decide which subprogram to use, but the
entire contents of `0'
are of interest to the
subprograms, so we just pass through everything the user typed.
Stata already has a ttest
command, so let's call our
new command mytt
. Here is what my first draft of
mytt
would look like:
| ADO-FILE: mytt.ado |
|---|
|
Notice what I did for testing this first version: I did not bother to actually
write tt_1
, tt_2
, and
tt_3
. I just wrote little stubs that displayed the
program name and the arguments that they received. That will allow me to test
whether my top-level program is working, and then I can fill in the
calculations and whatever else is necessary later.
Also note that I did not create separate files tt_1.ado
,
tt_2.ado
, and tt_3.ado
containing programs
tt_1
,
tt_2
, and tt_3
—I just
put the tt_*
programs at the end of mytt.ado
. I will have a lot to say about this shortly, but
for now, just notice that I can do this and that it certainly is convenient.
Let's test our program and see how it is working:
. mytt
varlist required
r(100);
Well, the error message is not exactly right, but I could probably live with it. Let's see if it understands syntax 1:
. mytt mpg=20
tt_1 mpg=20
Our program executes tt_1
as it should. Let's check
the other two syntaxes:
. mytt mpg=weight
tt_2 mpg=weight. mytt mpg, by(foreign)
tt_3 mpg, by(foreign)
Okay, our switching program, mytt
, works as it should.
Our top-level program will pass along more than it should. For instance, typing
mytt mpg
without the by()
option makes no sense, and yet
. mytt mpg
tt_3 mpg
but we can handle that in tt_3
. All that is required
of mytt
is that it get us into the right subprogram.
The small messages produced by the tt_*
subroutines
may have disguised how much we have just accomplished, so let me emphasize it.
We have looked at what the user typed, and we have determined from that the
correct statistical approach.
If the user types mytt mpg=20
, our program has figured
out that the user has requested a test against a constant and branched off to
the appropriate routine, which will contain the appropriate statistical
formula, for that problem.
If the user types mytt mpg=weight
, mytt knows that the
user has requested a test of the equality of means in a matched sample and so
mytt branches off to the appropriate routine, which will contain the
appropriate formula, for that problem.
If the user types mytt mpg, by(foreign)
, mytt knows
that this is the test of the equality of means in unmatched data, so it
branches off to the appropriate routine, which will eventually contain the
appropriate formula, for that problem.
Categorizing
. mytt mpg=20
. mytt mpg=weight
. mytt mpg, by(foreign)
is a sophisticated problem in pattern recognition.
Before continuing with our development of the ttest
equivalent mytt
, I want to make two comments about
subprograms, one substantive and the other Stata specific.
Substantively, did you notice how I go about writing a program? I assume
solutions to big pieces of the problem and work on one piece at a time. My
assumed solutions form the subprograms, in this case
tt_1
, tt_2
, and
tt_3
. Most problems lend themselves to this
approach, where I start at the top and peel off one layer of the problem at a
time. The advantages of this approach are
display
statements.The second advantage cannot be emphasized enough.  It won't work; debugging will be difficult; and worse, if you made a design mistake, which is easy to do, you will be tempted to patch around it to still make use of the rest of your glorious code.
At this stage in developing mytt
, I have no investment
in tt_1
, tt_2
, and tt_3
. If I have not thought carefully enough about this
problem and now find myself looking at an unwritable or inelegant tt_1
, I can change the design at the top right now, and
nothing is lost.
Now, concerning Stata, I want you to notice that I put the program
s for tt_1
, tt_2
, and tt_3
in
mytt.ado
. Did you know I could do that? Let me show you
something else. First, note that mytt
works:
. mytt mpg=20
tt_1 mpg=20
That means that the mytt
program executed and that
mytt
passed control along to the tt_1
program because it was that subprogram that produced
the message tt_1 mpg=20
. In fact, the tt_1
program reads
program tt_1
display "tt_1 `0'"
end
and that means that, if I type tt_1 this is a test
,
tt_1
would display tt_1 this is a test
.
Let's try it:
. tt_1 this is a test
unrecognized command
r(199);
Clearly, the program tt_1
must exist—mytt used
it—so how can tt_1
be an unrecognized command?
Let's try mytt one more time:
. mytt mpg=20
tt_1 mpg=20
I invite you to look back at mytt.ado
. The only line
that could be producing the message is in the program tt_1
. If you would like, you can go back and modify the
definition of tt_1
by adding the line display "Hello from tt_1"
before the display
that is already there. Resave
mytt.ado
, type discard
at the
Stata prompt, and try the experiment again. Here is what will happen if you do
that:
. mytt mpg=20
Hello from tt_1 tt_1 mpg=20. tt_1 this is a test
unrecognized command r(199);
This happens because tt_1
is a subprogram of mytt, and
Stata knows it. Program tt_1
is eligible for
execution by any other program in the mytt.ado
file
but is unknown outside that file. It is a private subprogram. In fact, program dir
reveals this:
. program dir
mytt.tt_3 ado 80
mytt.tt_2 ado 80
mytt.tt_1 ado 80
mytt ado 288
--------
528
program dir
shows that there is a program called mytt
loaded as an ado-file, and it shows that there are
mytt.tt_1
, mytt.tt_2
, and
mytt.tt_3
. "mytt.tt_1" is not really the name of the
program; that is just program dir
jargon for "there is
a program called tt_1
callable only from within the
mytt system".
Private subprograms are useful because
Number 2 comes about because the names really are private. There could, for
instance, be a subroutine named kappa
in the mytt.ado
file, and Stata would not confuse that kappa
with the Stata
command kappa
. If program
kappa
appeared in mytt.ado
, all references to the command
kappa
inside the ado-file would be to the locally
defined program. All references outside the ado-file would be to the Stata
kappa
command.
Clarification: you do not have complete freedom to name subprograms. Built-in Stata commands—commands implemented in the Stata binary executable—cannot be redefined. This freedom, however, extends to subprograms having the same name as other ado-files, or even subprograms within other ado-files where there is no confusion.
Write a program disyntax1
that takes the most common
elements of Stata syntax and displays the contents of each macro created by the
syntax
command. For example, you might use the auto
dataset,
. disyntax1 mpg price = 1 using some_file if rep78<. & make=="AMC Concord" in 1/25
varlist contains |mpg price|
exp contains |= 1 |
using contains |using `"some_file"'|
if contains |if rep78<. & make=="AMC Concord" |
in contains |in 1/25|
Modify the above program to also display the following types of options:
by()
, detail
, and
offset()
. Here by()
should
require a variable list, and offset should accept only a number. For example,
you might use the auto dataset,
. disyntax2 mpg, by(foreign) detail offset(10)
varlist contains |mpg|
exp contains ||
using contains ||
if contains ||
in contains ||
by contains |foreign|
detail contains |detail|
offset contains |10|
Write a program myci1
that uses the returned values of
summarize
to construct and display the limits of a 95%
CI for the mean. For example, you might use the auto dataset,
. summ mpg
(output). myci1
ll = 19.979121 ul = 22.615473
Modify the previous program so that it gives a meaningful error message if
r(mean)
or r(sd)
is
missing.


Microverse Project!
Microverse Program Rocks!
This is a tribute page for the microverse program
For more information click here.


There is the global resource to manage in MagickWand API. This module implements automatic global resource management through reference counting.
Instantiates the MagickWand API.
Warning
Don’t call this function directly. Use increment_refcount() and decrement_refcount() functions instead.
Cleans up the MagickWand API.
Warning
Don’t call this function directly. Use increment_refcount() and decrement_refcount() functions instead.
Increments the reference_count and instantiates the MagickWand API if it is the first use.
Decrements the reference_count and cleans up the MagickWand API if it will be no more used.
Abstract base class for MagickWand object that requires resource management. Its all subclasses manage the resource semiautomatically and support with statement as well:
with Resource() as resource:
# use the resource...
pass
It doesn’t implement constructor by itself, so subclasses should implement it. Every constructor should assign the pointer of its resource data into resource attribute inside of with allocate() context. For example:
class Pizza(Resource):
'''My pizza yummy.'''
def __init__(self):
with self.allocate():
self.resource = library.NewPizza()
New in version 0.1.2.
Allocates the memory for the resource explicitly. Its subclasses should assign the created resource into resource attribute inside of this context. For example:
with resource.allocate():
resource.resource = library.NewResource()
(ctypes.CFUNCTYPE) The ctypes function that clears an exception of the resource.
Note
It is an abstract attribute that has to be implemented in the subclass.
(ctypes.CFUNCTYPE) The ctypes function that destroys the resource.
Note
It is an abstract attribute that has to be implemented in the subclass.
(ctypes.CFUNCTYPE) The ctypes function that gets an exception from the resource.
Note
It is an abstract attribute that has to be implemented in the subclass.
(ctypes.CFUNCTYPE) The ctypes predicate function that returns whether the given pointer (that contains a resource data usuaully) is a valid resource.
Note
It is an abstract attribute that has to be implemented in the subclass.
Cleans up the resource explicitly. If you use the resource in with statement, it was called implicitly so have not to call it.
Gets a current exception instance.
| Returns: | a current exception. it can be None as well if any errors aren’t occurred |
|---|---|
| Return type: | wand.exceptions.WandException |
Raises an exception or warning if it has occurred.
Internal pointer to the resource instance. It may raise DestroyedResourceError when the resource has destroyed already.
An error that rises when some code tries access to an already destroyed resource.
Changed in version 0.3.0: It becomes a subtype of wand.exceptions.WandException.


Sammy's
Home
About Us
Contact
Contact
Us
Please fill out the form below to contact us
Name
Email
Message


Man City lose court case for trying to block UEFA investigation into FFP case
Man City have been attempting to block a UEFA investigation into their alleged breaches of Financial Fair Play regulations
by Rich Jones, https://www.mirror.co.uk/authors/rich-jones/Manchester City have lost their case attempting to block a UEFA investigation into their finances.
The Premier League champions have been charged with breaching Financial Fair Play regulations.
They appealed to the Court of Arbitration for Sport in a bid to prevent the investigation.
But their case has been thrown out, leaving them facing potential sanctions from the European governing body.
The news comes with City set to avoid a Champions League ban as punishment for potential breach of Financial Fair Play rules.
The Athletic have claimed UEFA are struggling to enforce their own regulations and City will avoid missing out on competing in Europe's top club competition.
More to follow.


Note: To complete these procedures, you must be assigned a role having the necessary permissions. To determine your role, follow the directions in Participant roles. For a basic understanding of roles and permissions, see Permissions and roles: Overview.
You can direct your site's syllabus to an HTML, PDF, or Microsoft Word file that you've uploaded to Resources, or to an external URL. To redirect your syllabus, follow the appropriate instructions below.
Note: If you don't see the Syllabus tool on your site's menubar, add it before following the instructions below. See Adding, editing, removing, hiding, or reordering tools.
To display an external URL, such as a web page on your department's server:
Syllabus
.
Create/Edit
, and then Redirect
.
Save
.To display an HTML, PDF, or Microsoft Word file:
Resources
.
Ctrl
-click) the filename and select the copy command for
your browser (i.e., for Internet Explorer, select Copy
Shortcut
; for Firefox, select Copy Link Location
).
Syllabus
.
Create/Edit
, and then Redirect
.
Ctrl-v
; for Mac OS X, Command-v
).
Save
.Note: Selecting a PDF file as your syllabus will cause a new window to open for Mac users using Firefox.


Friday-March 13, 2020
Latest funding rounds on Index.co
Apps
- How to see where you're logged in on Facebook, Twitter, and Instagram
- WhatsApp is bringing dark mode to desktop (but you can't use it yet)
- No spoilers: How to mute words and phrases on Twitter
- How to find that one Instagram filter everyone else is using
- Twitter tests labeling and correcting 'harmfully misleading' tweets by politicians
Gear
- Fujifilm unveils the X-T4, its new and improved flagship mirrorless camera
- I tried Huawei’s foldable Mate Xs — it’s badass, but fucking expensive
- Apple might launch an ARM-based Mac with its own chipset in 2021
- Everything you need to know about Honor’s just-launched 9X Pro
- Samsung temporarily shuts down a factory in South Korea due to Coronavirus
Tech
- Deep learning advances are boosting computer vision — but there's still clear limits
- Social media conspiracies blame coronavirus on 5G internet
- Porn sites are designed to keep us hooked — and take all our hard data
- IBM and David Clark Cause announce 2020 Call For Code Challenge
- Researchers found a cure for diabetes (in lab mice)
Creative
- Instagram's decision to hide photoshopped images is a disservice to art
- How to design better buttons
- Giphy debuts Arcade, a platform for making and playing 'microgames'
- Microsoft's new font for devs is very aesthetically pleasing (and free)
- How to build a production and recording studio that fits in a backpack
Podium
Insights
- Satoshi Nakaboto: ‘Bitcoin down along with global markets, thx corona :(’
- 3 top tips to help you be a good boss
- Customer Success: Metrics are worthless if you don't deliver outcomes
- Share what you've learned running a startup on Growth Quarters
- Here's how much Warren Buffett would've made buying Bitcoin instead of JP Morgan
Launch
- Alexis Ohanian and Serj Tankian team up to help build a social network for Armenia
- Google Assistant gets its own phone number in India
- Pam and Angela from The Office are re-watching the show for their new podcast
- Bethesda wants you to test its game streaming tech with DOOM on iOS this year
- Mozilla rolls out new automated crypto-jacking filtering in Firefox
Distract
- Netflix added a top 10 list of its most-watched content — here’s how to find it
- Hasbro announces 7 new D&D games starting with Baldur's Gate 3
- Rumor: Call of Duty to launch free 'Warzone' battle royale game as early as February 18
- Facebook changes its ad rules over Bloomberg's cringey memes
- Canon announces the EOS R5, fixing the original's biggest problems
Designs.ai Logomaker Premium Plan
$99 $18.99
The 2020 Complete Digital Copywriting Master Class Bundle
$699.90 $38.99
The 2020 Complete Java Master Class Bundle
$1066 $33.99
StackSkills Unlimited: Lifetime Access
$1495 $59


VARIANT class
(PHP 4 >= 4.1.0, PHP 5, PHP 7)
Description
The VARIANT is COM's equivalent of the PHP zval; it is a structure that can
contain a value with a range of different possible types. The VARIANT class
provided by the COM extension allows you to have more control over the way that
PHP passes values to and from COM.
$vVar = new VARIANT($var)
Methods
VARIANT::__construct ([ mixed $value [, int $type [, int $codepage ]]] )
VARIANT class constructor. Parameters:
value
initial value. if omitted, or set to NULL an VT_EMPTY object is created.
type
specifies the content type of the VARIANT object. Possible values are one
of the VT_XXX 预定义常量. In PHP versions prior to PHP 5, you could force
PHP to pass a variant object by reference by OR'ing VT_BYREF with the type.
In PHP 5, this hack is not supported; instead, PHP 5 can detect parameters
passed by reference automatically; they do not even need to be passed as
VARIANT objects. Consult the MSDN library for additional information on the
VARIANT type.
codepage
specifies the codepage that is used to convert strings to unicode. See the
parameter of the same name in the COM class for more information.
PHP versions prior to PHP 5 define a number of (undocumented) virtual
properties for instances of the VARIANT class; these properties have all been
removed in PHP 5 in favour of its more natural syntax; these differences are
best highlighted by example:
Example #1 Variant example, PHP 4.x style
type . "
";
print "The value is " . $v->value . "
";
?>
Example #2 Variant example, PHP 5 style
";
print "The value is " . $v . "
";
?>
The reason for the change is that, internally, the COM extension sees VARIANT,
COM and DOTNET classes as the same thing, and the design philosophy for these
classes is that all property and member accesses are passed through to COM with
no interference. The new syntax is more natural and less effort, and most of
the removed virtual properties didn't make any sense in a PHP context in any
case.
Note:
PHP 5 takes a much simpler approach to handling VARIANTs; when returning a
value or fetching a variant property, the variant is converted to a PHP
value only when there is a direct mapping between the types that would not
result in a loss of information. In all other cases, the result is returned
as an instance of the VARIANT class. You can force PHP to convert or
evaluate the variant as a PHP native type by using a casting operator
explicitly, or implicitly casting to a string by printing it. You may use
the wide range of variant functions to perform arithmetic operations on
variants without forcing a conversion or risking a loss of data.
See also variant_get_type().
User Contributed Notes 4 notes
===============================================================================
If you are frustrated that print_r($obj) (where $obj is something returned from
a call to a function on a COM object) does not return anything helpful, and
that variant_get_type($obj) just returns a number, the function you are
actually after is:
com_print_typeinfo($obj);
It lists all functions, variables, their types in a human-readable (well,
programmer-readable) format. Lovely!
===============================================================================
With thanks to Harald Radi and Wez Furlong.
Some VBA functions have optional parameters. Sometimes the parameters you want
to pass are not consecutive.
e.g.
GoTo What:=wdGoToBookmark, Name="BookMarkName"
GoTo(wdGoToBookmark,,,"BookMarkName)
In PHP, the "blank" parameters need to be empty.
Which is ...
Version}\n";
// Open a new document with bookmarks of YourName and YourAge.
$word->Documents->Open('C:/Unfilled.DOC');
// Fill in the information from the form.
$word->Selection->GoTo(wdGoToBookmark,$empty,$empty,'YourName'); // Note use of
wdGoToBookmark, from the typelibrary and the use of $empty.
$word->Selection->TypeText($_GET['YourName']);
$word->Selection->GoTo(wdGoToBookmark,$empty,$empty,'YourAge');
$word->Selection->TypeText($_GET['YourAge']);
// Save it, close word and finish.
$word->Documents[1]->SaveAs("C:/{$_GET['YourName']}.doc");
$word->Quit();
$word->Release();
$word = null;
print "Word closed.\n";
?>
The example document is ...
Hello [Bookmark of YourName], you are [Bookmark of YourAge] years old.
and it would be called ...
word.php?YourName=Richard%20Quadling&YourAge=35
Regards,
Richard.
===============================================================================
Running PHP 4.3.2 on Windows 2000 I had to use the following expression to
create an empty Variant:
type // ==> 1
?>
NOT
type // ==> 0
?>
The two expressions return different Variant type values!
===============================================================================
value; # Will print 9.34
# Now an integer
$varINT= new Variant("9.34 Printed as an integer",VT_INT);
print "Value:". $varINT->value; # Will print 9
# Now a string
$varSTR= new Variant("9.34 Printed as a string",VT_BSTR);
print "Value:". $varSTR->value; # Will 9.34 Printed as a string
?>


Woman's body found in water at side of Wolverhampton road
Medics and police were called to Dirtyfoot Lane, Wolverhampton, after the grim discovery on Saturday, November 2
by Jordan Coussins, https://www.birminghammail.co.uk/authors/jordan-coussins/A major police investigation has been launched after a woman's body was found in water at the side of a road in Wolverhampton.
Emergency crews – including the Midlands Air Ambulance – were called to Dirtyfoot Lane, Lower Penn, after the grisly discovery at around 1.30pm on Saturday, November 2.
Nothing could be done to save the woman and she was confirmed dead at the scene, a spokesman for West Midlands Ambulance Service confirmed.
The rural road was closed for more than 24 hours as forensic officers from Staffordshire Police scoured the scene for clues.
A spokesman for West Midlands Ambulance Service said: “We were called to Dirtyfoot Lane, Wolverhampton, to reports of a woman in the water.
“Two ambulances, two paramedic officers, a community first responder and the Midlands Air Ambulance was sent to the scene.
“On arrival, crews quickly found it apparent that nothing could be done to save the patient and she was pronounced dead at the scene.”
Staffordshire Police has still yet to release anything official on the incident.
To keep up-to-date with crime in your community, join the Black Country Crime Watch Facebook group where you will be alerted to any suspicious or criminal behaviour happening in your area.
Keep up-to-date with all things Walsall on our Walsall Facebook page - where you'll get the latest news, travel, weather and events in your area.


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import config.ViewConfig @import model.des._ @import model.RepaymentDataNoRiskingStatus @import model.PeriodKey @import model.Vrn @import formaters.CommonFormatter @this( viewsHelpers: views.ViewsHelpers, viewConfig: ViewConfig ) @( repayments: List[RepaymentDataNoRiskingStatus], vrn : Vrn, appender: String)( implicit request: Request[_], message: Messages, )
| @Messages("multiple_repayment_details.received_on") | @Messages("multiple_repayment_details.accounting_period") | @Messages("multiple_repayment_details.amount_claimed") | Status |
|---|---|---|---|
| @{CommonFormatter.formatDate(onePayment.returnCreationDate)} | @onePayment.period | £@{CommonFormatter.formatAmount(onePayment.amount)} | @if(appender == "_completed"){ @Messages("multiple_repayment_details.history_accounting_period") @onePayment.period } else{ @Messages("multiple_repayment_details.view_progress_accounting_period") @onePayment.period } |


Author - Mark Virtue
Total Time - 10 Hours
UNIX is a family of operating systems. UNIX Shell is common in text-based or command-line UNIX programs. The commands of UNIX shell are compatible with all brands of UNIX, including Linux. This tutorial teaches the fundamentals of UNIX Shell even if you have no prior knowledge of UNIX or UNIX Shell commands.
Author Mark Virtue helps you get a better understanding thorough demonstrations of processes such as logging in, copying files, combining programs, using telnet, and more.
To get started learning from this experienced instructor now, simply click one of the topics below.
(To view the movies below, you must have QuickTime installed)
Introduction
About this Course
Audience and PrerequisitesUnderstanding UNIX
What is UNIX?
UNIX History
Which UNIX?
UNIX ArchitectureUnderstanding the UNIX Shell
What is the UNIX Shell?
Which Shell?
Logging In
Basic Commands
Command Syntax
Getting Help
Logging OutFiles and Directories
Intro & Commands for Files and Directories
Filenames and File Types
Wildcards
Displaying File Contents
Comparing Files
Copying, Moving and Renaming Files
Deleting Files
Hidden Files
The "." and ".." Directories
Relative vs. Absolute Paths
Working with Directories
Finding Files
Archiving FilesSecurity
Users and Groups
File Protection Overview
Changing File Permissions
Changing File Ownership
Changing File Group
A Dangerous Security LoopholeCombining Programs - Pipes and Filters
Standard Output
Standard Input
Standard Input and Output
About Filters
Common Filters
Searching for Text in Files
Standard ErrorProcess Control
About Processes
Running Commands Asynchronously
Killing Processes
Jobs
More Process Control
Scheduling Commandsvi - A UNIX Text Editor
Understanding vi
Manipulating Files
Moving Around
Basic Editing
Advanced Editing
Configuring viThe UNIX File System
Introduction to the Unix File System
How Files are Stored
Understanding Links
Linking Files
Symbolic Links
UNIX File Types
MountingCommunication
Using telnet
Using mailCustomizing Your Shell Environment
Changing your Login Shell
Your .profile
Environment Variables
Your PATH
Your Prompt
Korn Shell Command-line Editing
Other Shell Customization Options
The End


Portfolio
We hold equites that we find attractive and employ our cash in an index fund until we find investment opportunities. We try to approach investing with a risk-avoidance approach. We invest in companies with a high margin of safety to avoid downside risk, and adequately diversify to avoid systematic risk. We aim to hold at least five companies with diversification between each company and within each company’s segments.
What we buy
Large, Unpopular Companies
Large companies that have adverse temporary developments tend to be undervalued by the market. These companies are excellent business to own, and when we can buy them for cheap we will.
Bargain Issues or Special Situations
We invest in securities that trade below Net Current Asset Value as long as they meet our investment criteria. If it is feasible with our amount of capital, we will invest in special situations or workarounds.


PARAGRAPH
Now that we know who you are, I know who I am. I'm not a mistake! It all makes sense! In a comic, you know how you can tell who the arch-villain's going to be? He's the exact opposite of the hero.  I should've known way back when... You know why, David? Because of the kids. They called me Mr Glass.
 Motherfucker do that shit to me, he better paralyze my ass, 'cause I'll kill the motherfucker, know what I'm sayin'?
| Table head | Table head | Table head |
|---|---|---|
| tfoot>td | tfoot>td | tfoot>td |
| TD #1 | TD #2 | TD #3 |
| TD #1 | TD #2 | TD #3 |
mark
element represents a run of text in one document marked or highlighted for reference purposes, due to its relevance in another context
abbr
markup used)
b
markup used - just bolding with unspecified semantics)
cite
markup used)
a[i] = b[i] + c[i);
(computer code; code
markup used)
del
markup used)
dfn
markup used for the term being defined)
em
markup used for emphasizing a word)
i
markup used)
ins
markup used)
kbd
markup used for text indicating keyboard input)
Hello!(
q
markup used for quotation)
She said(a quotation inside a quotation)Hello!
samp
markup used for sample output)
small
markup used)
strong
markup used)
sub
and
sup
markup) work inside running text, we need some
dummy text around constructs like x1 and H2O
(where subscripts occur). So here is some fill so that
you will (hopefully) see whether and how badly the subscripts
and superscripts mess up vertical spacing between lines.
Now superscripts: Mlle, 1st, and then some
mathematical notations: ex, sin2 x,
and some nested superscripts (exponents) too:
ex2 and f(x)g(x)a+b+c
(where 2 and a+b+c should appear as exponents of exponents).
u
markup used)
cat
filename displays the file specified by the filename (var
markup used to indicate a word as a variable).
(function(win)
{
/**
* @author Felipe Hefler
* www.underscoreattack.com
*/
win.console.log('Hello World');
})(window);


iiiAnalytics
info * intelligence * insights
For Data Science Training .
Contact/WhatsApp : +91 929 0000 292
About Us
iii
Analytics
is a startup based out of Hyderabad, India., Which provides Best quality Data Science training at affordable price, there is a special discount for Students and people who are looking for job..
.
Root cause Analytics
Root cause analysis (RCA) is a method of problem solving used for identifying the root causes of faults or problems..
DashBoard Setup
DashBoard setup to track imp. Insights.
Increase the profitability
By analyzing the factors using Statistics ,Machine Learning and Artificial Intelligence Techniques , Increase the Profitability.
.
Predictive Analytics
a variety of statistical techniques from predictive modeling, machine learning, and data mining that analyze current and historical facts to make predictions about future or otherwise unknown events..
And many more...
Return on Investment
Minimize the Revenue Leakage
Better understand the business to take great decisions..


Simple struct to hold boxes for testing.
More...
Simple struct to hold boxes for testing.
- Examples:
- tests/box_face_test.cpp.
template<typename T >
| void TestBox::DimsSet |
( |
std::initializer_list< T > |
dim_vals | ) |
|
|
inline |
| double TestBox::LargestDim |
( |
| ) |
|
|
inline |
| int TestBox::LargestDimIdx |
( |
| ) |
|
|
inline |
| std::vector<double> TestBox::dims |
| std::string TestBox::name |
| Eigen::Vector3f TestBox::pos |
| Eigen::Quaternionf TestBox::rot |
The documentation for this struct was generated from the following file:
- /root/workspace/src/amazon_project/tests/box_face_test.cpp


Simple Vi Mode v3 (rev 3)
You can change keys while s key is pressed down.
Simple Vi Mode will be active by the following procedure.
- s key_down
-
any keys of vi operation key_down (h,
j, k,
l,...)
-
any keys of vi operation key_up (h,
j, k,
l,...)
-
Then Simple Vi Mode is active until you release
s key.
Example:
- Press s
- Press j
- Press k
- Release j
- Release k
- Release s
Key bindings:
- h: left arrow
- j: down arrow
- k: up arrow
- l: right arrow
- f: fn
- c: left control
- v: left option
- b: left command


This is where your learning starts. Go through these tutorials to learn JavaScriptMVC basics. Also check out these example apps
Learn how to install JavaScriptMVC. This is a prerequisite for most of the other tutorials.
Build, minify, test, and document a basic recipe application. This tutorial covers the major components of JavaScriptMVC.
A walkthrough of the MVC parts of jQueryMX. This is a must read if you want to understand how they work together.
Walks through StealJS's features.
Uses FuncUnit to write functional tests for the jQuery UI autocomplete widget.
From a small to large projects, covers the best way of organizing a JavaScriptMVC application and scaling it to meet future needs.
Build a simple widget that loads content with ajax. This walkthrough demonstrates how to make a site Google crawlable and searchable.
This guide details suggests a service layer design that minimizes the amount of extra work to get JavaScriptMVC running.
This guide outlines the things you have to look at when upgrading from version 3.0 or 3.1.


curl_easy_escape - URL encode the given string
NAME
curl_easy_escape - URL encodes the given string
SYNOPSIS
#include <curl/curl.h>
char *curl_easy_escape( CURL * curl , const char * string , int length );
DESCRIPTION
This function converts the given input string to a URL encoded string and returns that as a new allocated string. All input characters that are not a-z, A-Z, 0-9, '-', '.', '_' or '~' are converted to their "URL escaped" version (%NN where NN is a two-digit hexadecimal number).
If length is set to 0 (zero), curl_easy_escape uses strlen() on the input string to find out the size.
You must curl_free the returned string when you're done with it.
ENCODING
libcurl is typically not aware of, nor does it care about, character encodings. curl_easy_escape encodes the data byte-by-byte into the URL encoded version without knowledge or care for what particular character encoding the application or the receiving server may assume that the data uses.
The caller of curl_easy_escape must make sure that the data passed in to the function is encoded correctly.
AVAILABILITY
Added in 7.15.4 and replaces the old curl_escape function.
RETURN VALUE
A pointer to a zero terminated string or NULL if it failed.
EXAMPLE
CURL *curl = curl_easy_init(); if(curl) { char *output = curl_easy_escape(curl, "data to convert", 15); if(output) { printf("Encoded: %s\n", output); curl_free(output); } }
SEE ALSO
curl_easy_unescape, curl_free, RFC 3986
This HTML page was made with roffit.


| cb.reset.parameters {xgboost} | R Documentation |
Callback closure for resetting the booster's parameters at each iteration.
cb.reset.parameters(new_params)
new_params |
a list where each element corresponds to a parameter that needs to be reset.
Each element's value must be either a vector of values of length |
This is a "pre-iteration" callback function used to reset booster's parameters at the beginning of each iteration.
Note that when training is resumed from some previous model, and a function is used to
reset a parameter value, the nrounds
argument in this function would be the
the number of boosting rounds in the current training.
Callback function expects the following values to be set in its calling frame:
bst
or bst_folds
,
iteration
,
begin_iteration
,
end_iteration
.


public interface LogicInterface
Task
objects as well as methods to interact with the
UIInterface
and StorageInterface
components via pass-through
methods.| Modifier and Type | Method and Description |
|---|---|
void |
addTask(Task task)
|
void |
clearRedoHistory()
Clears the redo stack.
|
void |
clearUndoHistory()
Clears the undo history stack until the root history is reached.
|
void |
display()
Sends the master list of
Task objects to the UIInterface
component to be displayed. |
void |
executeCommand(java.lang.String command)
Executes the command string entered by the user.
|
void |
feedback(FeedbackMessage feedback)
Pass-through method to
UIInterface.feedback(FeedbackMessage)
which displays the provided FeedbackMessage object to the user. |
java.util.ArrayList<Task> |
getAllTasks()
|
java.util.HashMap<java.lang.String,CommandHandler> |
getCommandHandlers()
Retrieves the
HashMap of reserved keyword strings to their
respective CommandHandler objects. |
java.io.File |
getDataFile()
Pass-through method to
StorageInterface.getDataFile() which
retrieves the File object representing the current FunDUE data
file. |
java.util.Set<java.lang.String> |
getReservedKeywords()
Retrieves the
Set of reserved keyword strings registered by
CommandHandler objects during FunDUE initialization. |
Task |
getTask(int index)
|
void |
injectDependencies(StorageInterface storage,
UIInterface textUI)
Injects the dependency on
StorageInterface and
UIInterface components into this LogicInterface
component. |
Filter |
popFilter()
Pass-through method to
UIInterface.popFilter() which pops the top
most Filter object from the filter chain stack and returns it. |
void |
pushFilter(Filter filter)
Pass-through method to
UIInterface.pushFilter(Filter) which
pushes the provided Filter object onto the filter chain stack. |
void |
readTasks()
Reads the master list of
Task objects from the FunDUE data file
using the StorageInterface component. |
void |
registerCommandHandler(CommandHandler handler)
Registers the provided
CommandHandler object with this
LogicInterface component. |
Task |
removeTask(int index)
|
Task |
removeTask(Task task)
|
java.util.ArrayList<Task> |
restoreCommandFromHistory()
Retrieves the most recent user command, if any.
|
java.util.ArrayList<Task> |
restoreCommandFromRedoHistory()
Obtains the last command the user undid, if any.
|
void |
setDataFile(java.io.File dataFile)
Pass-through method to
StorageInterface.setDataFile(File) which
sets the provided File object as the new FunDUE data file. |
boolean |
showChangeDataFilePathDialog()
Pass-through method to
UIInterface.showChangeDataFilePathDialog()
which shows a file picker dialog to let the user choose a new FunDUE data
file. |
boolean |
showHelpPage()
Pass-through method to
UIInterface.showHelpPage() which shows the
FunDUE Help Page window. |
void |
storeCommandInHistory()
Stores a deep copy of the master list of
Task objects into the
undo stack. |
void |
storeCommandInRedoHistory(java.util.ArrayList<Task> taskListToRedo)
Stores a deep copy of a
Task list into the redo stack. |
void |
writeTasks()
Writes the master list of
Task objects to the FunDUE data file
using the StorageInterface component. |
void injectDependencies(StorageInterface storage, UIInterface textUI)
StorageInterface
and
UIInterface
components into this LogicInterface
component.storage
- StorageInterface
component to be used. A handle to
this component will be retained for subsequent I/O method
calls.textUI
- UIInterface
component to be used. A handle to this
component will be retained for when a CommandHandler
requires data to be displayed or FeedbackMessage
to be
shown.java.util.Set<java.lang.String> getReservedKeywords()
Set
of reserved keyword strings registered by
CommandHandler
objects during FunDUE initialization.Set
of reserved keyword strings.registerCommandHandler(CommandHandler)
java.util.HashMap<java.lang.String,CommandHandler> getCommandHandlers()
HashMap
of reserved keyword strings to their
respective CommandHandler
objects.HashMap
mapping reserved keyword strings to their
respective CommandHandler
objects.void registerCommandHandler(CommandHandler handler)
CommandHandler
object with this
LogicInterface
component. Adds all reserved keyword strings
retrieved via CommandHandler.getReservedKeywords()
to the
complete set of reserved keywords and maps them to this
CommandHandler
object.handler
- CommandHandler
object to be registered.void executeCommand(java.lang.String command)
command
- Command string to execute.void display()
Task
objects to the UIInterface
component to be displayed.void feedback(FeedbackMessage feedback)
UIInterface.feedback(FeedbackMessage)
which displays the provided FeedbackMessage
object to the user.feedback
- FeedbackMessage
object to be displayed.boolean showChangeDataFilePathDialog()
UIInterface.showChangeDataFilePathDialog()
which shows a file picker dialog to let the user choose a new FunDUE data
file.True
if a file was chosen, false
otherwise.boolean showHelpPage()
UIInterface.showHelpPage()
which shows the
FunDUE Help Page window.True
if the FunDUE Help Page was shown, false
if
the window was already showing.Task getTask(int index) throws TaskNotFoundException
Task
object associated with the provided index from
the master list of Task
objects. The provided index is specific
to the way the UIInterface
component chooses to display and index
the master list of Task
objects. Therefore,
UIInterface.getTask(int)
is first called to retrieve the
Task
object from the UIInterface
component,
ArrayList.indexOf(Object)
is called to retrieve the corresponding
index in the master list of Task
objects, and finally that index
is used to retrieve the associated Task
object from the master
list of Task
objects.index
- Index of the Task
object to be retrieved.Task
object associated with the provided index.TaskNotFoundException
- Thrown when the provided index is out of bounds.Task removeTask(Task task) throws TaskNotFoundException
Task
object from the master list of Task
objects. ArrayList.remove(Object)
is called to remove the
Task
object from the master list of Task
objects.task
- Task
object to be removed.Task
object specified. An exception will be thrown if any
provided index is out of bounds.TaskNotFoundException
- Thrown when the provided index is out of bounds.Task removeTask(int index) throws TaskNotFoundException
Task
object associated with the provided index from
the master list of Task
objects. The provided index is specific
to the way the UIInterface
component chooses to display and index
the master list of Task
objects. Therefore,
UIInterface.getTask(int)
is first called to retrieve the
Task
object associated with the provided index, then
ArrayList.remove(Object)
is called to remove the Task
object from the master list of Task
objects.index
- Integer index of the Task
object to be removed.Task
object associated with the provided index. An
exception will be thrown if the provided index is out of bounds.TaskNotFoundException
- Thrown when the provided index is out of bounds.void readTasks()
Task
objects from the FunDUE data file
using the StorageInterface
component. The current master list of
Task
objects will be cleared first.void writeTasks()
Task
objects to the FunDUE data file
using the StorageInterface
component.java.io.File getDataFile()
StorageInterface.getDataFile()
which
retrieves the File
object representing the current FunDUE data
file.File
object representing the current FunDUE data file.void setDataFile(java.io.File dataFile)
StorageInterface.setDataFile(File)
which
sets the provided File
object as the new FunDUE data file.dataFile
- File
object to be used as the FunDUE data file.void pushFilter(Filter filter)
UIInterface.pushFilter(Filter)
which
pushes the provided Filter
object onto the filter chain stack.filter
- Filter
object to be pushed onto the filter chain
stack.Filter popFilter()
UIInterface.popFilter()
which pops the top
most Filter
object from the filter chain stack and returns it.void storeCommandInHistory()
Task
objects into the
undo stack.void storeCommandInRedoHistory(java.util.ArrayList<Task> taskListToRedo)
Task
list into the redo stack.taskListToRedo
- List of Task
objects to be stored in redo history.void clearUndoHistory()
void clearRedoHistory()
java.util.ArrayList<Task> restoreCommandFromHistory()
Task
list on its root
stack and will only be restored until that particular entry.Task
objects that will be displayed after
restoring from the undo stack.java.util.ArrayList<Task> restoreCommandFromRedoHistory()
Task
list and will only be restored until
that particular empty entry.Task
objects that will be displayed to the user
after restoring from the redo stack.


We provide functions to perform taxometric analyses. This package contains 44 functions, but only 5 should be called directly by users. CheckData() should be run prior to any taxometric analysis to ensure that the data are appropriate for taxometric analysis. RunTaxometrics() performs taxometric analyses for a sample of data. RunCCFIProfile() performs a series of taxometric analyses to generate a CCFI profile. CreateData() generates a sample of categorical or dimensional data. ClassifyCases() assigns cases to groups using the base-rate classification method.
| Version: | 2.3 |
| Published: | 2017-09-09 |
| Author: | John Ruscio and Shirley Wang |
| Maintainer: | John Ruscio <ruscio at tcnj.edu> |
| License: | MIT + file LICENSE |
| NeedsCompilation: | no |
| CRAN checks: | RTaxometrics results |
| Reference manual: | RTaxometrics.pdf |
| Package source: | RTaxometrics_2.3.tar.gz |
| Windows binaries: | r-devel: RTaxometrics_2.3.zip, r-release: RTaxometrics_2.3.zip, r-oldrel: RTaxometrics_2.3.zip |
| OS X binaries: | r-release: RTaxometrics_2.3.tgz, r-oldrel: RTaxometrics_2.3.tgz |
| Old sources: | RTaxometrics archive |
Please use the canonical form https://CRAN.R-project.org/package=RTaxometrics to link to this page.


We can form a
single united body,
while the enemy must split up into fractions.
Hence there will be a whole pitted against separate parts of a whole,
which means that we shall be many to the enemy's few.
[Sun Tzu, The Art of War - VI .14]
In traditional GO, there are just two opponent players, each one must defeat the other in order to win. Things may change completely if the number of players changes. I will consider 3 to 8 different players. In the following images, the 3rd player is red, the 4th is blue and the 5th is green.
After that, I'm going to approach the multiplayer problem in two other different dimensions. The movement type and the possibility of cooperation. Moves may be sequential (just like typical Go) or parallel, and players may cooperate in taking other prisoners (a kind of a local alliance to destroy some mutual enemies). The super KO rule should be enforced on every variant (no board repetition is allowed).
A 3 player Go should have the weaker players move first. If the players have the same strength, one way to compensate is to oblige the first player to pass in the 3rd turn.
A 4 player Go should also have the weaker players move first. If the players have the same strength, one way to compensate is to oblige the first and second player to pass in the 3rd turn.
The rule for 5 to 8 player Go, should give the 5th to 8th player a double move in the first turn, in order to compensate the lack of corners for those players. A typical opening for 5 player Go should be something like this:
The 5th player chooses to create an influence between the positional strongest pair (the 1st and 3rd players). Then, the game proceeds at one stone per player per turn.
The game should be very chaotic for more than 8 players. Probably, more than 4 players is already too much for a 19x19 board. Of course, larger boards may be used for larger set of players.
Multiplayer (Non Coop) Go
- All Go rules apply, except:
- The first turn movements are defined above.
- If a piece has no liberty due to two or more different stones, it is removed and eliminated (no one gets that prisoner).
In Go, each player is fighting all others in the sense that only one is going to win. In this variants, players may cooperate with each other. First we must define what cooperation means:
a) Tactical Cooperation, means that two or more players may encircle and capture stones from other players. If N players capture M stones, each player gets the larger integer smaller than M/N stones, and the rest goes to the one who dropped the last stone that did the capture. At the end of game, the shared territory values the larger integer smaller than M/N to each player and the rest does not go to anyone. The proportion of stones used in the capture of each player is irrelevant. The captured pieces are chosen first by the last turn player (e.g., if the 1st and 3rd player do a capture, the 3rd player chooses first what prisoners colors he wants).
Another way to deal with prisoners is presented by Allan Crossman (which adds a new tension to define what player will waste a move to capture stones): It doesn't matter who gets the prisoners. At the end of the game, the prisoners are simply put back in the territory of their own color, just like in two player go with territory counting. Only in this way is it possible for multiplayer go to have the same result whether territory or area scoring is used. I think this is a very desirable feature.
b) Strategic Cooperation, means that at the end of game, two or more players may unite their territories and prisoners (discounting each other prisoners) in order to get more than 5/12 of the game total points. 5/12 is the middle value between 1/3 (too easy) and 1/2 (too hard). If a solo victory means 1 point, a shared N player victory means 1/N points for each one (it does not matter which one of the allies has more, all players get the same points). Of course, if two alliances get more than 5/12 of the total points, wins the one with more points.
Tactical Cooperation There are 4 players (black, white, red and blue). If Red or Blue play at [1], they will capture the white stone and black will get nothing.
If Blue plays at [2], the 2 white stones are captured (Red receives one stone and Blue receives another). If Red plays at [2], he and Black will capture the 3 stones (2 for red and one for black) and Black is the last to choose.
If Black or Blue plays at [3], each one receives one white stone. If Red plays at [3] he will gain 2 white stones.
Strategic Cooperation Assume this end of game. Black has 10 prisoners (5 white, 5 red) and Red has 4 prisoners (3 black, one white). In territory, Black has 3, White has 15, Red has 13 and Blue 11. So, the total points are (10+4) + (3+15+13+11) = 56 points plus 18 neutral territories, i.e., 74 points.
If no alliances occur, Red will win (13+4=17 points). However, if an alliance can get 74*(5/12) = 30.8 points, they will win. If Black allies White then they would add 10 neutral territories and subtract the 5 white prisoners of black, so 8 points for black, 15 for white plus 10 new territories, i.e., 33 points. They can achieve a 2 way victory, so each one gets 1/2 point. They have a sure win, since a Red + Blue alliance would get only a total of 28 points.
Multiplayer (Coop) Go
- All Go rules apply, except:
- Tactical and strategic cooperation between players is allowed.
In Go, the moves are sequential. Each player waits for his turn. If we define parallel moves, a player only knows the opponents actual moves at the same time he makes his own move.
There is just a problem when two or more stones tries to occupy the same cell. If that happens, all those moves are not made (i.e., those players pass). This adds to Go a new kind of risk: if a drop is expected at cell C, will a player take the chance of loose one move?
The set of rules are stated below:
Multiplayer (Parallel & Non Coop) Go
- All Go rules apply, except:
- All moves on the same turn are simultaneous.
- Stone drops to the same cell are not made.
- All pieces with no liberties are removed.
Parallel Go Examples If White plays at [1] and Black at [2], then one white and one black stone are captured (top right position). If also Red plays at [3], then there are an extra white stone captured (bottom right position).
This one inherits the rules from Parallel Go and Cooperative Go. The only difference is that when capturing, the rest of the M/N division goes to the players that dropped the last stones, if this division (rest/N) is greater than one. The rest of the rest is eliminated.
Parallel Cooperative Go Examples If Black plays at [1] and White at [2], they will capture 5 stones (3 blues and 2 reds). Since they are just 2, each one receives 2 stones (5/2). Since the rest is 1 stone, that divided by 2 is less than one, then one captured stone will be eliminated. White chooses first what stones he wants, then Black. The remaining stone is then eliminated.
If Red plays at [3] and White plays at [4], the black stone is eliminated. If also Blue plays at [3], then the red and blue moves are not made, and the black stone are in Atari (with 3 white stones around it).


Each entry in the map has a sender's email address on the left-hand side, and an address to BCC to on the right. Alternately, the left-hand part can be a domain name prefixed by @, such as @example.com, which will match all sender addresses in that domain.


Tim Meadows: One of the longest-running cast members in the 37-year history of SATURDAY NIGHT LIVE, versatile comedian Tim Meadows crafted some of the series’ most memorable characters during his 10 years on the popular late night show. Such characters included Leon Phelps, The Ladies’ Man and Lionel Osbourne, host of the fictional public affairs show, Perspectives, as well as uncanny impressions of OJ Simpson, Ike Turner and Sammy Davis Jr. Meadows also played school principal in the hit comedy MEAN GIRLS and recently co-starred with Adam Sandler and Chris Rock in the blockbuster comedy GROWN UPS.
Born in Highland Park, Mich., and raised in Detroit, Meadows studied television and radio broadcasting at Wayne State University before performing improvisational comedy at the Soup Kitchen Saloon. In 1985, Meadows relocated to Chicago, where he first joined Improv-Olympic, and then the legendary comedy troupe Second City. During his three-years at Second City, he wrote and starred in productions of The Gods Must Be Lazy, with Chris Farley; It Was Thirty Years Ago Today; and Flag Smoking Permitted in Lobby Only, gaining a loyal following with his sharp comedic talent. In 1991, Meadows achieved the dreams of comics nationwide when producer Lorne Michaels asked him to join SNL as a featured player. Nominated for an Emmy® as part of the show’s writing team that same month, he later made the transition to cast member status two years afterward.
| Show Time | Price | Details |
|---|---|---|
|
Saturday, April 30, 2016 at 06:00 PM (Doors open at 05:30 PM) |
$18.00 |
07 tickets available
18 & over Two items minimum |
|
Saturday, April 30, 2016 at 08:30 PM (Doors open at 08:00 PM) |
$18.00 |
00 tickets available 18 & over Two items minimum |
|
Saturday, April 30, 2016 at 10:30 PM (Doors open at 10:00 PM) |
$18.00 |
17 tickets available 18 & over Two items minimum |


Is it fresh?
Is
Fruit/Vegetable
Fruit/Vegetable
in season?
Type a food above.
We will tell you here if they work in the current season.
Type in the name of a fruit or vegetable to see if it's in season!


Most times, a RobotWare specification will run without problems. Occasionally,
things will not work as expected.
To diagnose where your specification is going wrong, there are the following features:
Single step in the Editor
Allows you to execute the specification one step at a time. You should then see which
step fails. This is the recommended method for debugging a specification.
Debug statements
Record information to the log window. These can be put in a specification at various
places to monitor progress. This feature is available as a builtin RobotWare feature
under the Debugging category.