Fix failure to tokenize regexps after expressions like x.of
.
Better error message for unterminated template literals.
Properly handle allowAwaitOutsideFunction
in for statements.
Treat function declarations at the top level of modules like let bindings.
Don't allow async function declarations as the only statement under a label.
Make sure the walker and bin files are rebuilt on release (the previous release didn't get the up-to-date versions).
Fix crash in walker when walking a binding-less catch node.
Upgraded to Unicode 11.
In the walker, go back to allowing the baseVisitor
argument to be null to default to the default base everywhere.
Fix regression when passing null
as fourth argument to walk.recursive
.
Fix a bug in the walker that caused a crash when walking an object pattern spread.
Allow U+2028 and U+2029 in string when ECMAVersion >= 10.
Allow binding-less catch statements when ECMAVersion >= 10.
Add allowAwaitOutsideFunction
option for parsing top-level await
.
A second republish of the code in 5.5.1, this time with yarn, to hopefully get valid timestamps.
A republish of the code in 5.5.1 in an attempt to solve an issue with the file timestamps in the npm package being 0.
Fix regression in walker causing property values in object patterns to be walked as expressions.
Fix misleading error message for octal escapes in template strings.
Support object spread in the AST walker.
The identifier character categorization is now based on Unicode version 10.
Acorn will now validate the content of regular expressions, including new ES9 features.
5.4.0 somehow accidentally included an old version of walk.js.
Disallow duplicate or escaped flags on regular expressions.
Disallow octal escapes in strings in strict mode.
Add support for async iteration.
Add support for object spread and rest.
Fix parsing of floating point literals with leading zeroes in loose mode.
Allow duplicate property names in object patterns.
Don't allow static class methods named prototype
.
Disallow async functions directly under if
or else
.
Parse right-hand-side of for
/of
as an assignment expression.
Stricter parsing of for
/in
.
Don't allow unicode escapes in contextual keywords.
Parsing class members was factored into smaller methods to allow plugins to hook into it.
Fix a token context corruption bug.
Fix token context tracking for class
and function
in property-name position.
Make sure %*
isn't parsed as a valid operator.
The full
and fullAncestor
walkers no longer visit nodes multiple times.
Allow shorthand properties get
and set
to be followed by default values.
Disallow super
when not in callee or object position.
Support directive
property on directive expression statements.
Disable parsing of legacy HTML-style comments in modules.
Fix parsing of async methods whose names are keywords.
Fix problem with disambiguating regexp and division after a class.
Fix tokenizing of regexps in an object-desctructuring for
/of
loop and after yield
.
Parse zero-prefixed numbers with non-octal digits as decimal.
Allow object/array patterns in rest parameters.
Don't error when yield
is used as a property name.
Allow async
as a shorthand object property.
Make the ES module version of the loose parser actually work.
Implement the template literal revision proposal for ES9.
New walker functions full
and fullAncestor
.
Fix spurious duplicate variable definition errors for named functions.
A binary operator after a parenthesized arrow expression is no longer incorrectly treated as an error.
Raise an error for duplicated lexical bindings.
Fix spurious error when an assignement expression occurred after a spread expression.
Accept regular expressions after of
(in for
/of
), yield
(in a generator), and braced arrow functions.
Allow labels in front or var
declarations, even in strict mode.
Parse declarations following export default
as declaration nodes, not expressions. This means that class and function declarations nodes can now have null
as their id
.
Allow all forms of member expressions to be parenthesized as lvalue.
Don't expect semicolons after default-exported functions or classes, even when they are expressions.
Check for use of 'use strict'
directives in non-simple parameter
functions, even when already in strict mode.
Fix incorrect error raised for parenthesized simple assignment
targets, so that (x) = 1
parses again.
Solve spurious parenthesized pattern errors by temporarily erring on the side of accepting programs that our delayed errors don't handle correctly yet.
Accept invalidly rejected code like (x).y = 2
again.
Don't raise an error when a function inside strict code has a non-simple parameter list.
Fix exponential behavior (manifesting itself as a complete hang for even relatively small source files) introduced by the new 'use strict' check.
Disallow parenthesized pattern expressions.
Allow keywords as export names.
Don't allow the async
keyword to be parenthesized.
Properly raise an error when a keyword contains a character escape.
Allow "use strict"
to appear after other string literal expressions.
Disallow labeled declarations.
Fix issue with loading acorn_loose.js with an AMD loader.
Fix crash when export
was followed by a keyword that can't be
exported.
Allow regular function declarations inside single-statement if
branches in loose mode. Forbid them entirely in strict mode.
Properly parse properties named async
in ES2017 mode.
Fix bug where reserved words were broken in ES2017 mode.
Don't ignore period or 'e' characters after octal numbers.
Fix broken parsing for call expressions in default parameter values of arrow functions.
Fix false positives in duplicated export name errors.
The default ecmaVersion
option value is now 7.
A number of internal method signatures changed, so plugins might need to be updated.
The parser now raises errors on duplicated export names.
arguments
and eval
can now be used in shorthand properties.
Duplicate parameter names in non-simple argument lists now always produce an error.
The ecmaVersion
option now also accepts year-style version numbers
(2015, etc).
Support for async
/await
syntax when ecmaVersion
is >= 8.
Support for trailing commas in call expressions when ecmaVersion
is >= 8.
Fix bug in tokenizing of regexp operator after a function declaration.
Fix parser crash when parsing an array pattern with a hole.
Implement check against complex argument lists in functions that enable strict mode in ES7.
Improve handling of lack of unicode regexp support in host environment.
Properly reject shorthand properties whose name is a keyword.
Don't crash when the loose parser is called without options object.
Visitors created with visit.make
now have their base as prototype,
rather than copying properties into a fresh object.
Make it possible to use visit.ancestor
with a walk state.
Fix issue where the loose parser created invalid TemplateElement nodes for unclosed template literals.
Properly tokenize the division operator directly after a function expression.
Allow trailing comma in destructuring arrays.
The walker now allows defining handlers for CatchClause
nodes.
Allow update expressions as left-hand-side of the ES7 exponential operator.
Fix bug that accidentally made undefined
a reserved word when
parsing ES7.
The default value of the ecmaVersion
option is now 6 (used to be 5).
Support for comprehension syntax (which was dropped from the draft spec) has been removed.
let
and yield
are now “contextual keywords”, meaning you can
mostly use them as identifiers in ES5 non-strict code.
A parenthesized class or function expression after export default
is
now parsed correctly.
When ecmaVersion
is set to 7, Acorn will parse the exponentiation
operator (**
).
The identifier character ranges are now based on Unicode 8.0.0.
Plugins can now override the raiseRecoverable
method to override the
way non-critical errors are handled.
Stop allowing rest parameters in setters.
Make sure the loose parser always attaches a local
property to
ImportNamespaceSpecifier
nodes.
Disallow y
rexexp flag in ES5.
Disallow \00
and \000
escapes in strict mode.
Raise an error when an import name is a reserved word.
Fix crash in loose parser when parsing invalid object pattern.
Support plugins in the loose parser.
Don't crash when no options object is passed.
Add await
as a reserved word in module sources.
Disallow yield
in a parameter default value for a generator.
Forbid using a comma after a rest pattern in an array destructuring.
Support parsing stdin in command-line tool.
Fix bug where the walker walked an exported let
statement as an
expression.
Fix tokenizer support in the command-line tool.
In the loose parser, don't allow non-string-literals as import sources.
Stop allowing new.target
outside of functions.
Remove legacy guard
and guardedHandler
properties from try nodes.
Stop allowing multiple __proto__
properties on an object literal in
strict mode.
Don't allow rest parameters to be non-identifier patterns.
Check for duplicate paramter names in arrow functions.


WITNESS LIST Finance Committee (Subcommittee on State Investments) March 22, 2000-9:30A Comptroller of Public Accounts On: Demerson, Aaron (Comptroller of Public Accounts), Austin Doyle, Mike (Comptroller of Public Accounts), Austin Sachnowitz, Dan A. (Comptroller of Public Accounts), Austin Employees Retirement System On: Beckett, Sheila (Employees Retirement System), Austin Reissmant, Kathy-Ann (Employees Retirement System), Austin Teacher Retirement System On: Dunlap, Charles (Teacher Retirement System), Austin Jung, Ronnie (Teacher Retirement System), Austin Peavy, John (Teacher Retirement System), Dallas


git
complex, but worth it
aaron stacy
frontend engineer
waterfall is
hiring!
terminology
- vcs == source control
- git != github
motivation
we shouldn't can't do our job without source control
the joel test:
point #1
to understand why, understand how we got here
generation #1: tracking changes
- focused on one file at a time
- all local to your machine
- rcs, sccs
generation #2: sharing
- centralized "repositories"
- worked with directory trees
- networked
- svn, cvs, sourcesafe, tfs
but concurrency is hard
-
hard for humans just like computers
- multi-core processors
- the mythical man-month
- context switching
- context merging
generation #3: distributed vcs
- everyone has a copy of the entire history
- change-set oriented
- branching and merging are primary concerns
- git, mercurial, bazaar, bitkeeper, darcs
git vs. <something else>
- generally considered very fast
-
it doesn't try to be too intelligent
- many find it less intuitive
the most important part: the social side
- git has a huge community with tons of momentum
- it's good to be involved in a vibrant developer community
-
post your projects online
- don't wait until they're perfect!
alright let's draw
- a git repo is a DAG
- like a tree where branches grow back into each other
-
commits are the vertices
- snapshots
- diff's (incremental change sets)
- tracked by sha1 hashes, not version numbers
branches
- branches are just pointers or references to commits
- the main one is called master
- but there's not actually anything special about it
checkouts
- special pointer to your current branch: HEAD
- staging area of what you're about to commit: index
- working copy: everything outside of
.git
remotes
- could be on the same file system or another machine
-
can be accessed over different protocols
(
http
|ssh
|git
)
- main remote is called origin
- remotes are basically just URL's
- remote tracking branches
commits
- change your working copy
git add
adds it to the index
-
git commit
creates a new vertex in your repo's tree
fetching and merging
- fetching just adds vertices from a remote
-
merging is just moving the branch pointers together
- (and usually updating the HEAD)
-
it happens one of two ways:
- fast-forward
- three-way merge
- pull: fetch + merge
- push: inverse fetch + merge
crazy next-level stuff #1: feature branches
- you're working on a feature that takes a while
- you find out there's some massively horrible bug
- put all of your feature work in a separate branch
- do the bugfix and push it to production
- and pick up where you left off
- find a bug while you're doing something else
- you fix the bug
- but you don't want to commit it with the other thing
git add --interactive
crazy next-level stuff #3: async development
- one team member is responsible for the database
- one is responsible for the UI
- in a perfect world, do the database work first, then the UI
- in the real world, stuff is forgotten, miscommunicated, etc.
- shared git branch allows you to pass this work back and forth
- rest of the team doesn't see the half-baked change
how do people actually use it?
- git is incredibly flexible
- "framework for workflows"
- can be confusing, but some notable patterns are emerging
- note: there's always one central git repo
-
two main branches:
- develop: push to this any time you finish something
- master: should always be deployable
-
other short-lived branches:
- feature branches: kept local unless needed to share
-
release branches:
- start these shortly prior to release
- usually deployed to a staging area
- only bugfixes are committed
- merged back into development
- hotfix branches
(source)
- one branch: master
- master is always deployable
-
features and bugs all happen in descriptive branches off of master
-
usually involves rigorous code reviews
- github pull requests work well for this
- forking also supports this process
- deploy immediately after review
trade-offs
-
github flow is simpler
- …to learn
- …to build (graphical) tools for
- …to screw up production
-
github flow requires a greater understanding of the code
- every merge you need to know it doesn't break things
- less appropriate for legacy code
- github flow allows you to move faster
- if you've got multiple deployments, you need git flow
(you probably don't need git flow for school)


--- layout: post title: "Summary of papers" date: 2016-10-21 comments: true archive: false excerpt: Summary of some papers ---
Notes:
here here here
Notes:
here
Notes:
here
Notes:
here
Notes:
here
Notes:
Main Idea:
How to ease the trainig of deeper networks by
reformulating the layers as learning functions with reference to the
layer inputs, instead of learning unreferenced functions. This way
the neworks are easier to optimize you don't have more parameters
but actually less than some counterpart network architectures, for
instance VGG. In addition there is no degradastion on accuracy, on
the contrary, you can gain accuracy from the incrased depth.
The building block of the residual learning can be discribed as follows: We have a function \(F(\vec{x})\leftarrow\vec{x}\rightarrow\mbox{weight layer}\rightarrow\mbox{relu}\rightarrow\mbox{weight layer}\rightarrow\oplus\leftarrow\vec{x}\;\;\mbox{this is the identity}\rightarrow\mbox{relu}\).  Formally, denoting the desired underlying mapping as \(H(\vec{x})\), they let the stacked nonlinear layers fit another mapping of \(F(\vec{x}) := H(\vec{x}) - \vec{x}\). The original mapping is recast into \(F(\vec{x}) + \vec{x}\)
Identity Mapping by Shortcuts:
\(\vec{y} = F(\vec{x},
{\mathbf{W}_{i}}) + \vec{x}\) or perform a linear projection
\(\mathbf{W}_{x}\) by the shorcut connections to match the dimensions
\(\vec{y} = F(\vec{x}, {\mathbf{W}_{i}}) + \mathbf{W}_{x}\vec{x}\)
Title: Learning Deep Representations of Fine-Grained Visual Descriptors
State-of-the-art methods for zero-shot visual recognition formulate learning as a joint embedding problem of images and side information.
Summary:
Main Idea:
An integrated framework using convolutional networks
for classification, localizaiton and detection. They use a
multiscale and sliding window approach which can be efficiently
implemented in a convolutional network. They introduce an approach
to localization by learning to predict object boundaries. In this
approach bounding boxes are accumulated rather than suppressed in
order to increase detection confidence. They also show that
different tasks can be learned simultaneously using a single shared
network. The main point of the paper is to show that training a
convolutional network to simultaneously classify, locate and detect
objects in images can boost the of classification, detection and
localization of all tasks.
Pros:
Using a single conv net for classification, detection and
localization. They introduce a novel method for localization and
detection by accumulating predicted bounding boxes. They suggest
that if you combine many localization predictions then detection can
be performed without trainig on background samples and that way one
can avoid possible time-consuming and complicated bootstrapping
trainig phases, which ultimately allows the network to focus solely
on positive classes for higher accuracy. How do they achieve that?
Since objects of interest sometimes vary significantly in size and
position within the image, they combine three different ideas
experessed below. Regarding the terms localization and detection in
this paper the only difference is the evaluation criterion used and
usually both involve predicting the bounding box for each object in
the image.
The localization task is usually a convenient intermediate step between classification and detection which allows to evaluate the localization method independently of challenges specific to detection. Another important information is that classification and localization share the same dataset, while detection alos has additional data where objects can be smaller. Detection data also contains a set of images where certain objects are absent.
The filters in the feature extraction layers (1-5) are convolved across the entire image in one pass rather than sliding a fixed-size feature extractor over the image and then aggregating the results from different locations.
Many bounding boxes are fused into a single very high confidence box, while false positives disappear below the detection threshold due their lack of bounding box coherence and confidence. This suggests that their approach is naturally more robust to false positives coming from the pure-classification model than traditional non-maximum suppression, by rewarding bounding box coherence.
Cons:
Some of the training features in Krizhevsky's model were not
explored due to time constraints. Also they do not train the
regressor on bounding boxes with less than 50% overlap with the
input field of view.
Methodology:
Model design and trainig
Network trained on 1.2 million images with 1000 classes in total (ImageNet). The network model uses the same fixed input size as proposed by Krizhevsky et al. during traininig but turns to multi-scale for classification. Each image is downsampled with smallest dimesion 256 pixels. Then, they extract 5 random crops and their horizontal flips of size 221x221 pixels. These are then fed into the network as mini-batches of size 128. The weights are randomly initialized with \((\mu, \sigma) = (0.1 \times 10^{-2})\) and updated by SGD (stochastic gradient descent) with momentum of 0.6 and \(\el_{2}\) weight decay of \(1 \times 10^{-5}\), which is successively decreased by a factor of 0.5 after (30, 50, 60, 70, 80) epochs. Dropout with a rate of 0.5 is used on the fully connected layers (6th and 7th) in the classifier. Network architecture is described in the table below.
| Layer | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|---|---|---|---|---|---|---|---|---|
| Stage | conv+max | conv+max | conv | conv | conv+max | full | full | full |
| #channels | 96 | 256 | 512 | 1024 | 1024 | 3072 | 4096 | 1000 |
| Filter size | 11x11 | 5x5 | 3x3 | 3x3 | 3x3 | - | - | - |
| Conv. stride | 4x4 | 1x1 | 1x1 | 1x1 | 1x1 | - | - | - |
| Pooling size | 2x2 | 2x2 | - | - | 2x2 | - | - | - |
| Pooling stride | 2x2 | 2x2 | - | - | 2x2 | - | - | - |
| Zero-padding size | - | - | 1x1x1x1 | 1x1x1x1 | 1x1x1x1 | - | - | - |
| Spatial input size | 231x231 | 24x24 | 12x12 | 12x12 | 12x12 | 6x6 | 1x1 | 1x1 |
| Layer | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
|---|---|---|---|---|---|---|---|---|---|
| Stage | conv+max | conv+max | conv | conv | conv | conv+max | full | full | full |
| #channels | 96 | 256 | 512 | 512 | 1024 | 1024 | 4096 | 4096 | 1000 |
| Filter size | 7x7 | 7x7 | 3x3 | 3x3 | 3x3 | 3x3 | - | - | - |
| Conv. stride | 2x2 | 1x1 | 1x1 | 1x1 | 1x1 | 1x1 | - | - | - |
| Pooling size | 3x3 | 2x2 | - | - | - | 2x2 | - | - | - |
| Pooling stride | 3x3 | 2x2 | - | - | - | 2x2 | - | - | - |
| Zero-padding size | - | - | 1x1x1x1 | 1x1x1x1 | 1x1x1x1 | 1x1x1x1 | - | - | - |
| Spatial input size | 221x221 | 36x36 | 15x15 | 15x15 | 15x15 | 15x15 | 5x5 | 1x1 | 1x1 |
Another way to represent the network archiecture is the following one.
\(\mbox{Input}\rightarrow \left[\left[\mbox{conv}\rightarrow\mbox{max}\right]\times 2\rightarrow\left[\mbox{conv}\right]\times 2\rightarrow\left[\mbox{conv}\rightarrow\mbox{max}\right]\rightarrow \left[\mbox{fc}\rightarrow\mbox{dropout}\right]\times 3\right]\rightarrow\mbox{Output}\).
During training they treat the above architecture as non-spatial which means that it outputs feature maps of size 1x1 as opposed to the inference step, which produces spatial outputs. Layers 1-5 are similar to Krizhevsky et al. using relu non-linearities and max-pooling, but with the following differences:
The 3 last layers are applied in a sliding window fashion at test time. These fully connected layers can also be seen as 1x1 convolutions in spatial setting. The authors have also released a feature extractor named "OverFeat" including two models. A fast one \(\ref{tab:fast-model}\) and an accurate one \(\ref{tab:accurate-model}\).
As we already mentioned the authors use a multi-scale approach for the classificaiton task where they explore the entire image space by running the network at each location and at multiple scales using a sliding window. This particular approach allows significantly more views for voting where the result is a spatial map of C-dimensional vectors at each scale. For the resolution augmentation they follow the following steps:
Caption: 1D illustration (to scale) of output map computation for classificationUsing y-dimension from scale 2 as an example. 1.: 20 pixel unpooled layer 5 feature map. 2.: max pooling over non-overlapping 3 pixel groups, using offsets of \(\Delta\) = {0, 1, 2} pixels (red, green, blue respectively). 3.: The resulting 6 pixel pooled maps, for different \(\Delta\). 4.: 5 pixel classifier (layers 6,7) is applied in sliding window fashion to pooled maps, yielding 2 pixel by C maps for each \(\Delta\). 5.: reshaped into 6 pixel by C output maps.
The above operations can be viewed as shifting the classifier’s viewing window by 1 pixel through pooling layers without subsampling and using skip-kernels in the following layer. Or equivalently, as applying the final pooling layer and fully connected stack at every possible offset, and assembling the results by interleaving the outputs. The operation is repeated for the horizontal flipped version of each image and the final classification is produced by:
ConvNets and sliding window efficacy
put image here
Caption is Figure 5: The efficiency of ConvNets for detection. During training, a ConvNet produces only a single spatial output (top). But when applied at test time over a larger image, it produces a spatial output map, e.g. 2x2 (bottom). Since all layers are applied convolutionally, the extra computation required for the larger image is limited to the yellow regions. This diagram omits the feature dimension for simplicity.
For the localization task the authors replace the classifier layers by a regression network and train it to predict object bounding boxes at each spatial location and scale. Finally, they combine the regression predictions together, along with the classification results at each location.
For the generated predictions of object bounding boxes the authors simultaneously run the classifier and teh regressor network accross all locations and scales. Only the final regerssion layer needs to be recomputed after computing the classification network. The output of the final softmax layer for a class \(c\) at each location provides a score of confidence that an object of class \(c\) is present (though not necessarily fully contained) in the corresponding field of view. Thus they can assign a confidence to each bounding box. For the regression training the network has 2 fully-connected hidden layrers of size 4096 and 1024 channels.The final output layer has 4 units which specify the coordinates for the bounding box edges.
Image goes here
caption goes here Figure 6: Localization/Detection pipeline. The raw classifier/detector outputs a class and a con- fidence for each location (1st diagram). The resolution of these predictions can be increased using the method described in section 3.3 (2nd diagram). The regression then predicts the location scale of the object with respect to each window (3rd diagram). These bounding boxes are then merge and accumulated to a small number of objects (4th diagram)
Image goes here
Figure 7: Examples of bounding boxes produced by the regression network, before being com- bined into final predictions. The examples shown here are at a single scale. Predictions may be more optimal at other scales depending on the objects. Here, most of the bounding boxes which are initially organized as a grid, converge to a single location and scale. This indicates that the network is very confident in the location of the object, as opposed to being spread out randomly. The top left image shows that it can also correctly identify multiple location if several objects are present. The various aspect ratios of the predicted bounding boxes shows that the network is able to cope with various object poses.
They train the regression network using an \(\el_{2}\) loss between the predicted and true bounding box for each example having 1000 different versions, one for each class, they compare the prediction of the regressor net at each spatial location with the ground-truth bounding box, shifted into the frame of reference of the regressor’s translation offset within the convolution.
Finally they combine the predicitions via a greedy merge strategy applied to the regression bounding boxes using the following algorithm.
Image should go here
Caption on image
Application of the regression network to layer 5 features, at scale 2, for example.
(3x3) \(\Delta_{x}\), \(\Delta_{y}\) shifts.
Where matchsocre is the sum of the distance between centers of the two bounding boxes and the inersection area of the boxes, and boxmerge is the average of bounding boxes' coordinates. The final prediction is given by the merged bounding boxes with maximum class scores and it is computed by cummulatively adding the detection class outputs associated with the input windows from which each bounding box that was predicted.
Regarding the detection, it is similar to classification training but in a spatial manner. Multiple location of an image may be trained simultaneously. The main difference with the localization task, is the necessity to predict a background class when no object is present. Usually, negative examples are initially taken at random for training. Then the most offending negative errors are added to the training set in bootstrapping passes. Independent bootstrapping passes render training complicated and risk potential mismatches between the negative examples collection and training times. The size of bootstrapping passes needs to be tuned to make sure training does not overfit on a small set. To circumvent all these problems, they perform negative training on the fly, by selecting a few interesting negative examples per image such as random ones or most offending ones. This approach is more computationally expensive, but renders the procedure much simpler. And since the feature extraction is initially trained with the classification task, the detection fine-tuning is not as long anyway.
Experiments:
Multi-view approach proposed by the authors was
critical to obtaining good performance. Using only a single
centered crop, our regressor network achieves an error rate of
40%. By combining regressor predictions from all spatial locations
at two scales, they achieve a vastly better error rate of
31.5%. Adding a third and fourth scale further improves
performance to 30.0% error.


Home
Pages
Classes
Methods
Class and Module Index
Object
Test
Test::Unit
Test::Unit::AssertionFailedError
Test::Unit::Assertions
Test::Unit::Assertions::AssertExceptionHelper
Test::Unit::Assertions::AssertExceptionHelper::WrappedException
Test::Unit::Assertions::AssertionMessage
Test::Unit::Assertions::AssertionMessage::ArrayInspector
Test::Unit::Assertions::AssertionMessage::DelayedLiteral
Test::Unit::Assertions::AssertionMessage::HashInspector
Test::Unit::Assertions::AssertionMessage::Inspector
Test::Unit::Assertions::AssertionMessage::Literal
Test::Unit::Assertions::AssertionMessage::MaybeContainer
Test::Unit::Assertions::AssertionMessage::NumericInspector
Test::Unit::Assertions::AssertionMessage::Template
Test::Unit::Assertions::ThrowTagExtractor
Test::Unit::Attribute
Test::Unit::Attribute::BaseClassMethods
Test::Unit::Attribute::ClassMethods
Test::Unit::Attribute::StringifyKeyHash
Test::Unit::AttributeMatcher
Test::Unit::AutoRunner
Test::Unit::AutoRunner::StopOnFailureListener
Test::Unit::AutoRunnerLoader
Test::Unit::CodeSnippetFetcher
Test::Unit::Collector
Test::Unit::Collector::Descendant
Test::Unit::Collector::Dir
Test::Unit::Collector::Load
Test::Unit::Collector::ObjectSpace
Test::Unit::Collector::XML
Test::Unit::Collector::XML::Listener
Test::Unit::Color
Test::Unit::Color::Error
Test::Unit::Color::ParseError
Test::Unit::ColorScheme
Test::Unit::Data
Test::Unit::Data::ClassMethods
Test::Unit::Data::ClassMethods::Loader
Test::Unit::DataSets
Test::Unit::Diff
Test::Unit::Diff::Differ
Test::Unit::Diff::ReadableDiffer
Test::Unit::Diff::SequenceMatcher
Test::Unit::Diff::UTF8Line
Test::Unit::Diff::UnifiedDiffer
Test::Unit::Error
Test::Unit::ErrorHandler
Test::Unit::ExceptionHandler
Test::Unit::ExceptionHandler::ClassMethods
Test::Unit::Failure
Test::Unit::FailureHandler
Test::Unit::FaultLocationDetector
Test::Unit::Fixture
Test::Unit::Fixture::ClassMethods
Test::Unit::Fixture::Fixture
Test::Unit::Fixture::HookPoint
Test::Unit::MixColor
Test::Unit::Notification
Test::Unit::NotificationHandler
Test::Unit::NotifiedError
Test::Unit::NullResultContainerInitializer
Test::Unit::Omission
Test::Unit::OmissionHandler
Test::Unit::OmittedError
Test::Unit::PendedError
Test::Unit::Pending
Test::Unit::PendingHandler
Test::Unit::Priority
Test::Unit::Priority::Checker
Test::Unit::Priority::ClassMethods
Test::Unit::TestCase
Test::Unit::TestCase::InternalData
Test::Unit::TestCaseNotificationSupport
Test::Unit::TestCaseOmissionSupport
Test::Unit::TestCasePendingSupport
Test::Unit::TestResult
Test::Unit::TestResultErrorSupport
Test::Unit::TestResultFailureSupport
Test::Unit::TestResultNotificationSupport
Test::Unit::TestResultOmissionSupport
Test::Unit::TestResultPendingSupport
Test::Unit::TestSuite
Test::Unit::TestSuiteCreator
Test::Unit::UI
Test::Unit::UI::Console
Test::Unit::UI::Console::ColorizedReadableDiffer
Test::Unit::UI::Console::OutputLevel
Test::Unit::UI::Console::TestRunner
Test::Unit::UI::Emacs
Test::Unit::UI::Emacs::TestRunner
Test::Unit::UI::TestRunner
Test::Unit::UI::TestRunnerMediator
Test::Unit::UI::TestRunnerUtilities
Test::Unit::UI::XML
Test::Unit::UI::XML::TestRunner
Test::Unit::Util
Test::Unit::Util::BacktraceFilter
Test::Unit::Util::MethodOwnerFinder
Test::Unit::Util::Observable
Test::Unit::Util::Output
Test::Unit::Util::ProcWrapper
This is the API documentation for test-unit-3.3.5 Documentation.


Apple Honors Veterans Day With Website Banner, Activity Challenge on Apple Watch, and More
by Joe RossignolToday is Veterans Day in the United States and, as usual, Apple CEO Tim Cook has thanked veterans around the world for their service.
Apple is also showing its support for Veterans Day with a short message on its website: "Here's to the brave ones. We're proud to honor America's veterans and service members this Veterans Day and every day."
As noted by Kyle Seth Gray, Apple Watch users can earn a special Veterans Day badge in the Activity app today by completing any workout for 11 minutes or longer. The annual Activity Challenge, limited to the United States, also awards users with a Veterans Day sticker for use in the Messages app.
Last, Apple has highlighted how iPhone app Healium AR is helping veterans manage anxiety. The augmented reality app was created by former TV journalist Sarah Hill, who is profiled in the Apple Newsroom story.
November 11 also marks similar Remembrance Day or Armistice Day commemorations in many other countries.


YANBOG - Create Stations & Geocode Tests
[SKU_LOCATION_MAP MUST BE FILLED]
Wamas Host IP
STATIONS TEST. Set how many orders must be created to:
One Order to Each Station (order nº i.e.: 8100000)
One order goes through all stations (order nº i.e.: 8200000)
GEOCODES TESTS. Set 0-No or 1-Yes:
One order to each Aframe's geocode (order nº i.e.: 8300000)
One order to each Pbl's geocode (order nº i.e.: 8400000)
One order to each Pdc's geocode (order nº i.e.: 8500000)
Create and Send Files to Host


- Dashboard {% if request.resolver_match.view_name == "profile" or request.resolver_match.view_name == "profile_edit" or request.resolver_match.view_name == "password_change" %}
- Profile Information {% elif request.resolver_match.view_name == "pre_assessment" %}
- Pre-Assessment {% elif request.resolver_match.view_name == "pre_assessment_confirmation" %}
- Pre-Assessment
- Confirm Pre-Assessment {% elif request.resolver_match.view_name == "dashboard" or request.resolver_match.view_name == "deleted_questionnaires" %}
- Deleted Qs {% elif request.resolver_match.view_name == "q_add" %}
- New questionnaire {% elif q %} {% is_authorized q.id request.user as authorized %} {% if authorized %}
- History {% endif %}
- Questionnaire Details
- System Description
-
Primary and Supporting Assets
{% comment %}
- Use Cases
-
{% for u in q.usecase.all %}
- {{ u.name }} {% endfor %}
- Use Cases
-
Primary and Supporting Assets
{% comment %}
- Risk Assessment
- Risk Treatment
- Privacy Targets
- Report {% endif %}


You are the chosen ones, the valiant knights of programming who toil away, without rest, fixing our most awful code.
  Never gonna tell a lie and hurt you.”


Use the interactive charts below to explore the dataset
You must select a study subject from the dropdown in order to view data.


Fow aww youw uwu nyeeds >w< Pwease owo wesponsibwy
Based on the OWO Chrome extension by leafysweetsgarden


Unsupervised learning, as the name suggests, is the science of learning from unlabeled data. A look at the wikipedia page shows that this term has many interpretations:
(Task A) Learning a distribution from samples. (Examples: gaussian mixtures, topic models, variational autoencoders,..)
(Task B) Understanding latent structure in the data. This is not the same as (a); for example principal component analysis, clustering, manifold learning etc. identify latent structure but don’t learn a distribution per se.
(Task C) Feature Learning. Learn a mapping from datapoint $\rightarrow$ feature vector such that classification tasks are easier to carry out on feature vectors rather than datapoints. For example, unsupervised feature learning could help lower the amount of labeled samples needed for learning a classifier, or be useful for domain adaptation.
Task B is often a subcase of Task C, as the intended user of “structure found in data” are humans (scientists) who pour over the representation of data to gain some intuition about its properties, and these “properties” can be often phrased as a classification task.
This post explains the relationship between Tasks A and C, and why they get mixed up in students’ mind. We hope there is also some food for thought here for experts, namely, our discussion about the fragility of the usual “perplexity” definition of unsupervised learning. It explains why Task A doesn’t in practice lead to good enough solution for Task C. For example, it has been believed for many years that for deep learning, unsupervised pretraining should help supervised training, but this has been hard to show in practice.
The common theme: high level representations.
If $x$ is a datapoint, each of these methods seeks to map it to a new “high level” representation $h$ that captures its “essence.” This is why it helps to have access to $h$ when performing machine learning tasks on $x$ (e.g. classification). The difficulty of course is that “high-level representation” is not uniquely defined. For example, $x$ may be an image, and $h$ may contain the information that it contains a person and a dog. But another $h$ may say that it shows a poodle and a person wearing pyjamas standing on the beach. This nonuniqueness seems inherent.
Unsupervised learning tries to learn high-level representation using unlabeled data. Each method make an implicit assumption about how the hidden $h$ relates to the visible $x$. For example, in k-means clustering the hidden $h$ consists of labeling the datapoint with the index of the cluster it belongs to. Clearly, such a simple clustering-based representation has rather limited expressive power since it groups datapoints into disjoint classes: this limits its application for complicated settings. For example, if one clusters images according to the labels “human”, “animal” “plant” etc., then which cluster should contain an image showing a man and a dog standing in front of a tree?
The search for a descriptive language for talking about the possible relationships of representations and data leads us naturally to Bayesian models. (Note that these are viewed with some skepticism in machine learning theory – compared to assumptionless models like PAC learning, online learning, etc. – but we do not know of another suitable vocabulary in this setting.)
A Bayesian view
Bayesian approaches capture the relationship between the “high level” representation $h$ and the datapoint $x$ by postulating a joint distribution $p_{\theta}(x, h)$ of the data $x$ and representation $h$, such that $p_{\theta}(h)$ and the posterior $p_{\theta}(x \mid h)$ have a simple form as a function of the parameters $\theta$. These are also called latent variable probabilistic models, since $h$ is a latent (hidden) variable.
The standard goal in distribution learning is to find the $\theta$ that “best explains” the data (what we called Task (A)) above). This is formalized using maximum-likelihood estimation going back to Fisher (~1910-1920): find the $\theta$ that maximizes the log probability of the training data. Mathematically, indexing the samples with $t$, we can write this as
where
(Note that $\sum_{t} \log p_{\theta}(x_t)$ is also the empirical estimate of the cross-entropy $E_{x}[\log p_{\theta}(x)]$ of the distribution $p_{\theta}$, where $x$ is distributed according to $p^*$, the true distribution of the data. Thus the above method looks for the distribution with best cross-entropy on the empirical data, which is also log of the perplexity of $p_{\theta}$.)
In the limit of $t \to ∞$, this estimator is consistent (converges in probability to the ground-truth value) and efficient (has lowest asymptotic mean-square-error among all consistent estimators). See the Wikipedia page. (Aside: maximum likelihood estimation is often NP-hard, which is one of the reasons for the renaissance of the method-of-moments and tensor decomposition algorithms in learning latent variable models, which Rong wrote about some time ago.)
Toward task C: Representations arise from the posterior distribution
Simply learning the distribution $p_{\theta}(x, h)$ does not yield a representation per se. To get a distribution of $x$, we need access to the posterior $p_{\theta}(h \mid x)$: then a sample from this posterior can be used as a “representation” of a data-point $x$. (Aside: Sometimes, in settings when $p_{\theta}(h \mid x)$ has a simple description, this description can be viewed as the representation of $x$.)
Thus solving Task C requires learning distribution parameters $\theta$ and figuring out how to efficiently sample from the posterior distribution.
Note that the sampling problems for the posterior can be #-P hard for very simple families. The reason is that by Bayes law, $p_{\theta}(h \mid x) = \frac{p_{\theta}(h) p_{\theta}(x \mid h)}{p_{\theta}(x)}$. Even if the numerator is easy to calculate, as is the case for simple families, the $p_{\theta}(x)$ involves a big summation (or integral) and is often hard to calculate.
Note that the max-likelihood parameter estimation (Task A) and approximating the posterior distributions $p(h \mid x)$ (Task C) can have radically different complexities: Sometimes A is easy but C is NP-hard (example: topic modeling with “nice” topic-word matrices, but short documents, see also Bresler 2015); or vice versa (example: topic modeling with long documents, but worst-case chosen topic matrices Arora et al. 2011)
Of course, one may hope (as usual) that computational complexity is a worst-case notion and may not apply in practice. But there is a bigger issue with this setup, having to do with accuracy.
Why the above reasoning is fragile: Need for high accuracy
The above description assumes that the parametric model $p_{\theta}(x, h)$ for the data was exact whereas one imagines it is only approximate (i.e., suffers from modeling error). Furthermore, computational difficulties may restrict us to use approximately correct inference even if the model were exact. So in practice, we may only have an approximation $q(h|x)$ to the posterior distribution $p_{\theta}(h \mid x)$. (Below we describe a popular methods to compute such approximations.)
How good of an approximation to the true posterior do we need?
Recall, we are trying to answer this question through the lens of Task C, solving some classification task. We take the following point of view:
For $t=1, 2,\ldots,$ nature picked some $(h_t, x_t)$ from the joint distribution and presented us $x_t$. The true label $y_t$ of $x_t$ is $\mathcal{C}(h_t)$ where $\mathcal{C}$ is an unknown classifier. Our goal is classify according to these labels.
To simplify notation, assume the output of $\mathcal{C}$ is binary. If we wish to use $q(h \mid x)$ as a surrogate for the true posterior $p_{\theta}(h \mid x)$, we need to have $\Pr_{x_t, h_t \sim q(\cdot \mid x_t)} [\mathcal{C}(h_t) \neq y_t]$ is small as well.
How close must $q(h \mid x)$ and $p(h \mid x)$ be to let us conclude this? We will use KL divergence as “distance” between the distributions, for reasons that will become apparent in the following section. We claim the following:
CLAIM: The probability of obtaining different answers on classification tasks done using the ground truth $h$ versus the representations obtained using $q(h_t \mid x_t)$ is less than $\epsilon$ if $KL(q(h_t \mid x_t) \parallel p(h_t \mid x_t)) \leq 2\epsilon^2.$
Here’s a proof sketch. The natural distance these two distributions $q(h \mid x)$ and $p(h \mid x)$ with respect to accuracy of classification tasks is total variation (TV) distance. Indeed, if the TV distance between $q(h\mid x)$ and $p(h \mid x)$ is bounded by $\epsilon$, this implies that for any event $\Omega$,
The CLAIM now follows by instantiating this with the event $\Omega = $ “Classifier $\mathcal{C}$ outputs a different answer from $y_t$ given representation $h_t$ for input $x_t$”, and relating TV distance to KL divergence using Pinsker’s inequality, which gives
as we needed. This observation explains why solving Task A in practice does not automatically lead to very useful representations for classification tasks (Task C): the posterior distribution has to be learnt extremely accurately, which probably didn’t happen (either due to model mismatch or computational complexity).
The link between Tasks A and C: variational methods
As noted, distribution learning (Task A) via cross-entropy/maximum-likelihood fitting, and representation learning (Task C) via sampling the posterior are fairly distinct. Why do students often conflate the two? Because in practice the most frequent way to solve Task A does implicitly compute posteriors and thus also solves Task C.
The generic way to learn latent variable models involves variational methods, which can be viewed as a generalization of the famous EM algorithm (Dempster et al. 1977).
Variational methods maintain at all times a proposed distribution $q(h | x)$ (called variational distribution). The methods rely on the observation that for every such $q(h \mid x)$ the following lower bound holds \begin{equation} \log p(x) \geq E_{q(h \mid x)} \log p(x,h) + H(q(h\mid x)) \qquad (2). \end{equation} where $H$ denotes Shannon entropy (or differential entropy, depending on whether $x$ is discrete or continuous). The RHS above is often called the ELBO bound (ELBO = evidence-based lower bound). This inequality follows from a bit of algebra using non-negativity of KL divergence, applied to distributions $q(h \mid x)$ and $p(h\mid x)$. More concretely, the chain of inequalities is as follows,
Furthermore, equality is achieved if $q(h\mid x) = p(h\mid x)$. (This can be viewed as some kind of “duality” theorem for distributions, and dates all the way back to Gibbs. )
Algorithmically observation (2) is used by foregoing solving the maximum-likelihood optimization (1), and solving instead
Since the variables are naturally divided into two blocks: the model parameters $\theta$, and the variational distributions $q(h_t\mid x_t)$, a natural way to optimize the above is to alternate optimizing over each group, while keeping the other fixed. (This meta-algorithm is often called variational EM for obvious reasons.)
Of course, optimizing over all possible distributions $q$ is an ill-defined problem, so $q$ is constrained to lie in some parametric family (e.g., “ standard Gaussian transformed by depth $4$ neural nets of certain size and architecture”) such the above objective can be easily evaluated at least (typically it has a closed-form expression).
Clearly if the parametric family of distributions is expressive enough, and the (non-convex) optimization problem doesn’t get stuck in bad local minima, then variational EM algorithm will give us not only values of the parameters $\theta$ which are close to the ground-truth ones, but also variational distributions $q(h\mid x)$ which accurately track $p(h\mid x)$. But as we saw above, this accuracy would need to be very high to get meaningful representations.
Next Post
In the next post, we will describe our recent work further clarifying this issue of representation learning via a Bayesian viewpoint.


{% extends "layout.html" %} {% block content %} {% if current_user.is_authenticated %}
you're not logged in so the card isn't showing.
This website searches bookoutlet for books on your Goodreads Want to Read shelf
Login Sign Up {% endif %} {% endblock %}


Hello! I’m Sam.
I’m a web designer and developer.
I specialize in helping small businesses in the tourism industry reach their target audience by designing and building easy-to-navigate, SEO-optimized, custom websites. Using a holistic approach, I am well-versed in the entire brand and website creation processes.
I’ve worked hard to develop an eye for detail and enjoy working closely with my clients every step of the way. Handling everything from establishing user personas and defining brand personality to wireframing design concepts and building responsive websites from scratch, I’m dedicated to finding creative ways to meet my clients’ needs.
I’m excited by the wild world of web design and development and love the challenge of learning new skills and discovering different tools to deliver the best solutions for my clients.
As a traveling remote worker, I’ve spent the past several years hopping from country to country exploring new destinations. When I’m not at my computer, you can usually find me chowing down on delicious street food or kicking back at the nearest beach.


Tests that it is possible to request permission to display Web Notifications from a document context, for which the passed callback will be invoked with the requests' result. It also makes sure that not passing a callback won't result in a crash.


Waterwise Gardening Tips
By Fritz Kollmann - Water Conservation Garden Crew Leader
Break with convention! The long overdue conversion of thirsty, poorly adapted lawns and gardens can only happen if homeowners, property managers, landscape architects, garden designers and businesses can implement a sustainable ‘new normal’ by installing and properly maintaining attractive, low water gardens and landscapes.
Low water gardening is much like regular gardening with some key differences in plant selection, soil preparation, and irrigation systems.
Site Selection
- Ideally, your garden site will receive a full day of unobstructed sunlight and be free of large trees which can make establishment of new gardens somewhat more difficult. Shady, treed sites can be planted with low water use plants but keep in mind that the existing watering regiment will need to be maintained or even increased to ensure the health of the existing trees. Carefully observe your garden site over one or more seasons to determine how much light it receives, how well the soil drains, and where water collects or drains away from. Knowing your site characteristics will help you make informed decisions regarding soil preparation and plant selection.
Soil Preparation
- Prepare soil by clearing existing plants and weeds. Cover the garden area in a thin (up to 1”) layer of fine compost and any other necessary soil amendments, and till in or double dig roughly 4-6” deep.
- Many Utah soils are high in clay and drain poorly. However, many low water plants, especially succulents, require well drained soils. Incorporating a 1” thick layer of Utelite or other drainage improving amendment will greatly improve your chance of success.
Irrigation
- Drip irrigation systems provide the greatest water savings over time. There are several styles that work well for the home landscape. Surface drip tubing can work well but is somewhat unsightly unless pinned in place and covered with mulch.
- Converting your existing spray heads to large droplet spray heads also helps reduce water loss through evaporation and can save you the cost of renovating your entire irrigation system.
- Use a programmable timer with a rain or soil moisture sensor to provide a consistent watering schedule and avoid watering during or immediately after a rainstorm.
- Water deeply and consistently. Set irrigation run times to ensure that your soil is being moistened at least of 6” below the surface. A cycle soak program will help on slopes and in heavy clay soils, by giving water time to soak in rather than run off.
- Hydro-zone your plantings and irrigation zones. Grouping plants with the same water needs will ensure the success of your garden.
Plant Selection & Design
- If the thought of converting your whole yard to a water-wise landscape is intimidating, start small. Pick one area of your landscape to start with. There are many resources to help with the process. Consider hiring a garden designer and landscape company to install and maintain your garden. Let your chosen designer/landscaper know that you want a low water landscape! Check your designers plant choices to ensure that they are truly low water plants before approving a design.
- Be aware of the difference between water wise plants and drought tolerant plants. A water wise plant is one that requires less water than traditional garden plants in order to complete its life cycle. A drought tolerant plant is one which can survive an extended period with very little or no water, but may require regular watering to thrive. A drought tolerant plant will not necessarily perform well with less water over time while a water wise plant will.
- Select plants that are considered water wise for your region. Keep in mind that the term “water wise” is often used to describe plants that are well suited to a particular climate, rainfall amount and geographical area.
- Native plants, provided they are appropriate for your conditions, are often a good choice. However, not all native Utah plants are low water use plants. Utah natives from riparian zones and high elevations require regular watering. There is also a tremendous variety of plants from similar climates that make excellent garden subjects, both visually and ecologically. Visit Red Butte Garden or your local nursery and ask a horticulturist for recommendations.
Tips
- When planting (everything except succulents), create small berms around the edge of the root ball, on the surface of the soil to ensure deep, properly located water penetration. Watering deeply is essential in establishing all plants.
- Deep, regular watering (2-3x/week) is necessary during the establishment phase (approximately 2 years) of any garden, including low-water gardens.
- Once established, allow the soil to dry out 4” deep for clay soils and 2” deep for sandy soils before watering. If you’re unsure of your soil type, perform a soil test. Send a sample away to your local agricultural extension or do it yourself.
- Home soils tests are simple and free! Click this link for directions www.youtube.com/watch?v=XU6_lqCzxf0
- Improper planting depth and constantly wet conditions around the crown of low water plants often kills them. Be sure to plant your plants so that the top of the root ball is level with the surrounding soil and that water drains into the soil quickly.
- Mulch helps retain water and can prevent some weed seeds from germinating. Inorganic mulches such as gravel are best for low water gardens. Organic mulches can be problematic due to high nitrogen content, which can injure low water plants that hail from areas where rich, natural mulches and high nutrient soils do not occur. A thin (organic mulch applied at planting time, as long as it is not touching the base of plants, can provide some benefit during plant establishment.
- A hot, windy day can kill new plants! Be sure your plants don’t stay dry for too long on windy days until they are established.
- Even the toughest low water plants in xeric gardens benefit from occasional watering. A deep soaking every two to three weeks during the dry hot part of summer will keep your garden looking good it may also encourage plants to flower over a longer period and set seed, both of which are tremendously beneficial to pollinators and other wildlife.
Web Resources
Utah Low Water Demonstration Gardens
Recommended Reading
- High and Dry: Gardening with Cold Hardy Dryland Plants. By Robert Nold
- Plant Driven Design. By Lauren Springer Ogden, Scott Ogden
- Cacti and Succulents for Cold Climates: 274 Outstanding Species for Challenging Conditions, Leo J. Chance
- Combinations for Conservation: Recommended Plant Groupings for Low-Water Landscapes: Center for Water-Efficient Landscaping, Utah State University
- Water Wise -Native Plants for Intermountain Landscapes by Wendy Mee, Jared Barnes, Roger Kjelgren, Richard Sutton, Teresa Cerny and Craig Johnson
- Xeriscape Colorado: The Complete Guide. By Connie Lockhart Ellefson and David Winger
- Water-Efficient Landscaping in the Intermountain West. By Heidi Kratsch Utah State University


Six Weeks
Sign In
{% csrf_token %}
Email Address
Password
Remember me
Can't access your account?
Login Failed
Did you enter the right email address and password?
OK


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| api | 86.05% | 518/602 | 88.44% | 153/173 | 78.9% | 86/109 | 86.13% | 503/584 | |
| core | 87.21% | 1636/1876 | 72.4% | 535/739 | 82.89% | 252/304 | 87.41% | 1590/1819 | |
| core/operation | 97.67% | 84/86 | 94.44% | 17/18 | 94.12% | 16/17 | 97.5% | 78/80 | |
| core/snap | 95.43% | 522/547 | 91.32% | 242/265 | 93.88% | 92/98 | 95.47% | 506/530 | |
| core/snap/indexes | 95.49% | 127/133 | 100% | 10/10 | 85% | 34/40 | 95.16% | 118/124 | |
| core/stats | 91.55% | 65/71 | 75% | 12/16 | 86.67% | 13/15 | 90.63% | 58/64 | |
| core/storage | 75.51% | 37/49 | 50% | 6/12 | 66.67% | 8/12 | 74.47% | 35/47 | |
| core/util | 83.98% | 980/1167 | 70.53% | 469/665 | 84.96% | 192/226 | 84.43% | 927/1098 | |
| core/util/libs | 97.3% | 72/74 | 93.02% | 40/43 | 100% | 4/4 | 97.26% | 71/73 | |
| core/view | 87.88% | 732/833 | 75.94% | 262/345 | 89.19% | 132/148 | 87.53% | 709/810 | |
| core/view/filter | 95.81% | 206/215 | 91.74% | 100/109 | 94.29% | 33/35 | 95.71% | 201/210 | |
| realtime | 81.82% | 621/759 | 55.19% | 170/308 | 86.41% | 89/103 | 81.81% | 598/731 | |
| realtime/polling | 90% | 27/30 | 37.5% | 3/8 | 100% | 5/5 | 89.29% | 25/28 |


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
_
_
__fromPtr__(long)
- Static method in class org.opencv.calib3d.
StereoBM
__fromPtr__(long)
- Static method in class org.opencv.calib3d.
StereoMatcher
__fromPtr__(long)
- Static method in class org.opencv.calib3d.
StereoSGBM
__fromPtr__(long)
- Static method in class org.opencv.core.
Algorithm
__fromPtr__(long)
- Static method in class org.opencv.core.
TickMeter
__fromPtr__(long)
- Static method in class org.opencv.dnn.
DictValue
__fromPtr__(long)
- Static method in class org.opencv.dnn.
Layer
__fromPtr__(long)
- Static method in class org.opencv.dnn.
Net
__fromPtr__(long)
- Static method in class org.opencv.features2d.
AgastFeatureDetector
__fromPtr__(long)
- Static method in class org.opencv.features2d.
AKAZE
__fromPtr__(long)
- Static method in class org.opencv.features2d.
BFMatcher
__fromPtr__(long)
- Static method in class org.opencv.features2d.
BOWImgDescriptorExtractor
__fromPtr__(long)
- Static method in class org.opencv.features2d.
BOWKMeansTrainer
__fromPtr__(long)
- Static method in class org.opencv.features2d.
BOWTrainer
__fromPtr__(long)
- Static method in class org.opencv.features2d.
BRISK
__fromPtr__(long)
- Static method in class org.opencv.features2d.
DescriptorExtractor
Deprecated.
__fromPtr__(long)
- Static method in class org.opencv.features2d.
DescriptorMatcher
__fromPtr__(long)
- Static method in class org.opencv.features2d.
FastFeatureDetector
__fromPtr__(long)
- Static method in class org.opencv.features2d.
Feature2D
__fromPtr__(long)
- Static method in class org.opencv.features2d.
FeatureDetector
Deprecated.
__fromPtr__(long)
- Static method in class org.opencv.features2d.
FlannBasedMatcher
__fromPtr__(long)
- Static method in class org.opencv.features2d.
GFTTDetector
__fromPtr__(long)
- Static method in class org.opencv.features2d.
KAZE
__fromPtr__(long)
- Static method in class org.opencv.features2d.
MSER
__fromPtr__(long)
- Static method in class org.opencv.features2d.
ORB
__fromPtr__(long)
- Static method in class org.opencv.features2d.
Params
__fromPtr__(long)
- Static method in class org.opencv.imgproc.
CLAHE
__fromPtr__(long)
- Static method in class org.opencv.imgproc.
LineSegmentDetector
__fromPtr__(long)
- Static method in class org.opencv.imgproc.
Subdiv2D
__fromPtr__(long)
- Static method in class org.opencv.ml.
ANN_MLP
__fromPtr__(long)
- Static method in class org.opencv.ml.
ANN_MLP_ANNEAL
__fromPtr__(long)
- Static method in class org.opencv.ml.
Boost
__fromPtr__(long)
- Static method in class org.opencv.ml.
DTrees
__fromPtr__(long)
- Static method in class org.opencv.ml.
EM
__fromPtr__(long)
- Static method in class org.opencv.ml.
KNearest
__fromPtr__(long)
- Static method in class org.opencv.ml.
LogisticRegression
__fromPtr__(long)
- Static method in class org.opencv.ml.
NormalBayesClassifier
__fromPtr__(long)
- Static method in class org.opencv.ml.
ParamGrid
__fromPtr__(long)
- Static method in class org.opencv.ml.
RTrees
__fromPtr__(long)
- Static method in class org.opencv.ml.
StatModel
__fromPtr__(long)
- Static method in class org.opencv.ml.
SVM
__fromPtr__(long)
- Static method in class org.opencv.ml.
SVMSGD
__fromPtr__(long)
- Static method in class org.opencv.ml.
TrainData
__fromPtr__(long)
- Static method in class org.opencv.objdetect.
BaseCascadeClassifier
__fromPtr__(long)
- Static method in class org.opencv.objdetect.
CascadeClassifier
__fromPtr__(long)
- Static method in class org.opencv.objdetect.
HOGDescriptor
__fromPtr__(long)
- Static method in class org.opencv.photo.
AlignExposures
__fromPtr__(long)
- Static method in class org.opencv.photo.
AlignMTB
__fromPtr__(long)
- Static method in class org.opencv.photo.
CalibrateCRF
__fromPtr__(long)
- Static method in class org.opencv.photo.
CalibrateDebevec
__fromPtr__(long)
- Static method in class org.opencv.photo.
CalibrateRobertson
__fromPtr__(long)
- Static method in class org.opencv.photo.
MergeDebevec
__fromPtr__(long)
- Static method in class org.opencv.photo.
MergeExposures
__fromPtr__(long)
- Static method in class org.opencv.photo.
MergeMertens
__fromPtr__(long)
- Static method in class org.opencv.photo.
MergeRobertson
__fromPtr__(long)
- Static method in class org.opencv.photo.
Tonemap
__fromPtr__(long)
- Static method in class org.opencv.photo.
TonemapDrago
__fromPtr__(long)
- Static method in class org.opencv.photo.
TonemapDurand
__fromPtr__(long)
- Static method in class org.opencv.photo.
TonemapMantiuk
__fromPtr__(long)
- Static method in class org.opencv.photo.
TonemapReinhard
__fromPtr__(long)
- Static method in class org.opencv.video.
BackgroundSubtractor
__fromPtr__(long)
- Static method in class org.opencv.video.
BackgroundSubtractorKNN
__fromPtr__(long)
- Static method in class org.opencv.video.
BackgroundSubtractorMOG2
__fromPtr__(long)
- Static method in class org.opencv.video.
DenseOpticalFlow
__fromPtr__(long)
- Static method in class org.opencv.video.
DualTVL1OpticalFlow
__fromPtr__(long)
- Static method in class org.opencv.video.
FarnebackOpticalFlow
__fromPtr__(long)
- Static method in class org.opencv.video.
KalmanFilter
__fromPtr__(long)
- Static method in class org.opencv.video.
SparseOpticalFlow
__fromPtr__(long)
- Static method in class org.opencv.video.
SparsePyrLKOpticalFlow
__fromPtr__(long)
- Static method in class org.opencv.videoio.
VideoCapture
__fromPtr__(long)
- Static method in class org.opencv.videoio.
VideoWriter
_channels
- Static variable in class org.opencv.core.
MatOfByte
_channels
- Static variable in class org.opencv.core.
MatOfDMatch
_channels
- Static variable in class org.opencv.core.
MatOfDouble
_channels
- Static variable in class org.opencv.core.
MatOfFloat
_channels
- Static variable in class org.opencv.core.
MatOfFloat4
_channels
- Static variable in class org.opencv.core.
MatOfFloat6
_channels
- Static variable in class org.opencv.core.
MatOfInt
_channels
- Static variable in class org.opencv.core.
MatOfInt4
_channels
- Static variable in class org.opencv.core.
MatOfKeyPoint
_channels
- Static variable in class org.opencv.core.
MatOfPoint
_channels
- Static variable in class org.opencv.core.
MatOfPoint2f
_channels
- Static variable in class org.opencv.core.
MatOfPoint3
_channels
- Static variable in class org.opencv.core.
MatOfPoint3f
_channels
- Static variable in class org.opencv.core.
MatOfRect
_channels
- Static variable in class org.opencv.core.
MatOfRect2d
_channels
- Static variable in class org.opencv.core.
MatOfRotatedRect
_depth
- Static variable in class org.opencv.core.
MatOfByte
_depth
- Static variable in class org.opencv.core.
MatOfDMatch
_depth
- Static variable in class org.opencv.core.
MatOfDouble
_depth
- Static variable in class org.opencv.core.
MatOfFloat
_depth
- Static variable in class org.opencv.core.
MatOfFloat4
_depth
- Static variable in class org.opencv.core.
MatOfFloat6
_depth
- Static variable in class org.opencv.core.
MatOfInt
_depth
- Static variable in class org.opencv.core.
MatOfInt4
_depth
- Static variable in class org.opencv.core.
MatOfKeyPoint
_depth
- Static variable in class org.opencv.core.
MatOfPoint
_depth
- Static variable in class org.opencv.core.
MatOfPoint2f
_depth
- Static variable in class org.opencv.core.
MatOfPoint3
_depth
- Static variable in class org.opencv.core.
MatOfPoint3f
_depth
- Static variable in class org.opencv.core.
MatOfRect
_depth
- Static variable in class org.opencv.core.
MatOfRect2d
_depth
- Static variable in class org.opencv.core.
MatOfRotatedRect
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
_
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes


#assign beanvalidation="active">
We can optionally add bean validation.
Example: HelloController
Add a dependency on controller-validator-hibernate. This will transitively bring in a dependency on hibernate-validator.
io.dinject controller-validator-hibernate 1.1
Add @Valid
annotation on controllers that we want bean validation to
be included for. When we do this controller methods that take a request payload
will then have the request bean (populated by JSON payload or form parameters)
validated before it is passed to the controller method.
For the controller method below:
@Post("saveform") @Form void saveForm(HelloForm helloForm) { ... }
The generated code now includes a validation of the helloForm before it is passed to the controller method. The generated code is:
ApiBuilder.post("/hello/saveform", ctx -> { ctx.status(201); HelloForm helloForm = new HelloForm( ctx.formParam("name"), ctx.formParam("email") ); helloForm.url = ctx.formParam("url"); helloForm.startDate = toLocalDate(ctx.formParam("startDate")); validator.validate(helloForm); // validation added here !! controller.saveForm(helloForm); });
Add an exception handler for ValidationException
like the one below.
With bean validation we collect all the validation errors and these are included
in the exception as a map keyed by the property path.
exception.getErrors() in the handler below is returning a Map<String, Object>
app.exception(ValidationException.class, (exception, ctx) -> { Map<|String,Object> map = new LinkedHashMap<>(); map.put("message", exception.getMessage()); map.put("errors", exception.getErrors()); ctx.json(map); ctx.status(exception.getStatus()); });<@next "JAX-RS Comparison" "jaxrs"/>


Our pride and passion. We review all client situations and application options. Advising the client before an application is made.
We provide preparation and representation services for all Immigration matters that may have an appeal option or are in front of an Immigration Tribunal, ( Immigration Review Board). These services include Hearing representation
We provide full application assessment, preparation, and representation for claims to be submitted, or that have been submitted.
Immigration assessments. Our pride and passion. We review all client situations and application options. Advising the client before an application is made. Federal and Provincial economic Programs: We create and implement an employer driven strategies to ensure your company, organization, and potential employee will adhere to all Provincial and Federal requirements. We monitor the complete process every step of the way. For all Family Class Programs: We provide preparation and representation services for all Family Class Programs, including Immigration Review Board representation. For Immigration Appeals or Tribunal Representation: We provide preparation and representation services for all Immigration matters that may have an appeal option or are in front of an Immigration Tribunal, ( Immigration Review Board). These services include Hearing representation. For Refugee Claims: We provide full application assessment, preparation, and representation for claims to be submitted, or that have been submitted.


Article
Microsoft Authenticode Signing Instructions
| Article ID: | AR190 | |
| Version: | 26.0 | |
| Published: | 11/14/2007 | |
| Updated: | 10/27/2010 |
Description
The following instructions help you get started. If you need more information, contact your browser or OS platform vendor directly.
STEP BY STEP OVERVIEW
Step 1: Download Signing Tools
The Platform SDK for Microsoft Windows contains the information and tools you need to develop Windows-based applications. You can use this SDK to develop both 32- and 64-bit applications. Make sure that you are running the most current version of the SDK.
Windows NT and Windows Me/98/95: SignTool.exe is not supported.
To install the minimal tools needed for signing your files only install the Tools and Redistributable Components of the Microsoft Windows Core SDK.
Step 2: Operating System Overview
Windows XP/WIndows 2000/Windows 2003
To sign, use the SIGNTOOL.EXE utility. The SignTool tool is a command-line tool that digitally signs files, verifies signatures in files, or time stamps files. For information about why signing files is important, see Introduction to Code Signing. The tool is installed in the \Bin folder of the Microsoft Windows Software Development Kit (SDK) installation path.
To sign, use the SIGNTOOL.EXE utility. The SignTool tool is a command-line tool that digitally signs files, verifies signatures in files, or time stamps files. For information about why signing files is important, see Introduction to Code Signing. The tool is installed in the \Bin folder of the Microsoft Windows Software Development Kit (SDK) installation path.
SignTool is available as part of the Windows SDK, which you can download from http://go.microsoft.com/fwlink/?linkid=84091
You will also need your Digital ID file (generally called MyCredentials.spc) and your private key (MyPrivateKey.pvk).
Windows Vista/Windows 7
To sign, use the SIGNTOOL.EXE utility. The SignTool tool is a command-line tool that digitally signs files, verifies signatures in files, or time stamps files. For information about why signing files is important, see Introduction to Code Signing. The tool is installed in the \Bin folder of the Microsoft Windows Software Development Kit (SDK) installation path.
Windows Vista/Windows 7
To sign, use the SIGNTOOL.EXE utility. The SignTool tool is a command-line tool that digitally signs files, verifies signatures in files, or time stamps files. For information about why signing files is important, see Introduction to Code Signing. The tool is installed in the \Bin folder of the Microsoft Windows Software Development Kit (SDK) installation path.
SignTool is available as part of the Windows SDK, which you can download from http://go.microsoft.com/fwlink/?linkid=84091
Your Digital ID will install in certificate store within Internet Explorer
Windows Vista/7/2008 Windows Hardware Quality Labs (WHQL)
Please refer to this Knowledge Base Solution SO5820.
Windows Vista/7/2008 Windows Hardware Quality Labs (WHQL)
Please refer to this Knowledge Base Solution SO5820.
Step 3: Signing Files by Operating System
To have your signatures recognised by Windows XP/WIndows 2000/Windows 2003:
Go to: Start > Run
- Type CMD > click OK
- At the command prompt, enter the directory where signtool exists
- Run the following:
signtool.exe sign /f mycert.pfx /p <password> /t http://timestamp.verisign.com/scripts/timstamp.dll /v "<file to be signed>"
Note: Replace <password> with the password specified when the PFX file was created (omit /p if there was no password set). Replace <file to be signed> with the name of the file you will be signing.
Test Your Signature
The Platform SDK SIGNTOOL.EXE utility contains a command to check a digital signature before distributing your file.
- Go to: Start > Run
- Type CMD > click OK
- At the command prompt, enter the directory where signtool exists
- Run the following:
signtool verify /pa /v <your-file-name>
Note: Replace <your-file-name> with the name of the file you signed
When a code signed file is downloaded from a Web site using Internet Explorer, it will display this certificate to the user. If the file is tampered with in any way after it has been signed, the user will be notified and given the option to refuse installation.
To have your signatures recognised by all versions of Windows including Vista and 7:
For Windows Vista 64-bit and Windows 7 the signing process has changed. The code cannot simply be signed, it also needs to be "cross-signed" with a certificate provided by Microsoft.
For instructions on how to sign code for use in Windows Vista 64-bit and Windows 7, please follow the signing instructions from the following solution: SO5820
Note: Code signed using the cross-signing method will be recognised on all versions of Windows. It is therefore not required to create separately signed versions of the code for use on Windows 2000 - XP and Windows Vista/7.
Related Information
For more information about signing see the Microsoft Developer Network Website.


|
This is an open source software available on GitHub under Apache 2 License. Contact: Patrice Lopez. This bibliographical analysis demo is based on the grobid-istex web services, see GitHub project. For documentation about GROBID, please visit the Grobid Wiki pages. |


|
SimJava v2.0 |
||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
| GraphListener | Graph event listener interface. |
| Traceable | The trace command types. |
| TraceListener | Timing diagram event listener interface |
| Class Summary | |
| GraphClearObject | Clears graph |
| GraphData | Stores a single data point. |
| GraphDiagram | This class represents the graph application. |
| GraphDisplay | Displays graph. |
| GraphEqn | Generates sin/cos graph from equation. |
| GraphEventObject | The basic graph event class. |
| GraphLoader | Converts graph from URL to GraphEventListener format. |
| GraphSetAxes | Stores a command to set the axes labels for this graph. |
| GraphSetScale | Sets scale |
| GraphWindow | A graph diagram in a separate window (and thread). |
| TimingDiagram | This class represents the timing diagram application. |
| TimingWindow | Timing diagram in a separate window |
| TraceEventObject | Timing diagram event object. |
| TraceLoader | TraceLoader Converts trace from URL to TraceEventListener format |
| TraceSaver | TraceSaver Stores trace events in a file. |
Classes concerned with providing user controlled diagrams for simulations.
|
SimJava v2.0 |
||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


{# Section headers and sectioning taken from https://www.w3schools.com/bootstrap/tryit.asp?filename=trybs_scrollspy&stacked=h on October 5, 2018 #}
Assignment 3
Name
Contact
About
About
Education
Education
Skills
Skills
Work
Work


THE SAINT A film review by Michael Redman Copyright 1997 Michael Redman
*1/2 (out of ****)
Val Kilmer's super spy for hire is one part James Bond and one part "Fletch" (a decidedly mediocre Chevy Chase film based on an excellent detective book series) and doesn't succeed as well as even the Chase disaster.
A master of disguise with a habit of using the names of Catholic saints, Simon Templar is hired by a Russian crime boss turned politician to find the secret of cold fusion. In order to do so, he must romance Emma Russell (an uninteresting and apparently uninterested Elisabeth Shue), the good doctor with the secret. Although not a part of his plan, he falls in love with her.
Someone has stolen all of the fuel oil in Moscow and whoever comes up with a new energy source will rule the country. If you can swallow that far-fetched plot device, perhaps you'll go along with the rest of the film. I found almost everything that happens equally implausible.
Kilmer can be a first-rate actor, but it doesn't happen here. The scenes of his Fabio-inspired long-haired naked lounging are difficult to take seriously. In all fairness, the two women that I spoke to after the movie both loved the film...but then they had serious Val Kilmer blinders on.
[This appeared in the 4/10/97 "Bloomington Voice", Bloomington Indiana. Michael Redman can be reached at<EMAIL_ADDRESS>]
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Our current designs as of Jan. 2019 :
D E C | 2 0 1 8
J A N | 2 0 1 8
N O V | 2 0 1 7
Our prices are based off the client's budget.
Hit us up; We love meeting new people!
The B L K | Privilege Company + B L K | Privilege Productions


It's different with Identities. This is what we can obtain by hitting by some operaters.
Operator(Pattern) = Attributes
In this way we can only get most of the complete information. Most of time it's the partial information we got. Operation is a defined process or algorithm that we accept the patterns were treated by a series of design transform and the properties are the result of such process.
属性举例：


{% block content %} Let us predict who would have tweeted your message! {% if prediction %} We predict {{ prediction }} would have tweeted this message! {% endif %} {% endblock %}


Dialogue
- Added a "Hand Quality" player condition for checking strengths of hands (ex. targeting a pair of fives vs a pair of twos).
Bug Fixes
- Fixed crash in the Writing Aid when trying to respond to a situation that can no longer be linked to any dialogue.
- Fixed issue with "play once" lines not being unique being editor sessions.
- The Z Layer in the Advanced tab can now take a negative value.
- Fixed issue with filter conditions where you could type fake values into the filter field and click create to crash. This could also happen if you tried filtering on "target" on a case that has no target.
- Filtering on 0 of a certain opponent will no longer display that opponent in the dialogue tree's Target column.
- Fixed issue where tooltips would appear on the label instead of the ? icon next to the label.
- Fixed issue where targeted lines were not indexed properly. This would cause issues such as the Banter Wizard and Writing Aid not picking up lines from characters with names earlier in the alphabet. This will require a one-time slower launch in order to rebuild the index.
- Fixed issue where characters that change gender (Lucina, Chihiro, etc.) would trigger false positives for validation warnings about being the wrong gender for a case.


Please submit the form only when you are sure that you are going to contribute.
Clicking on the Submit button will take you to the insta mojo page where you can make your donation.
By default, the donation amount will be 500.
You can change it and make it same as the amount you have mentioned in the form.
If you want to make a direct transfer, here are the account details.
Account name KATAKHALI Swapnopuron Welfare Society
Account number<PHONE_NUMBER>05
Bank name ICICI bank
Branch kasba
Ifsc code ICIC0000983


What morning isn't improved by a trip to urgent care? Oh right, this one. (Just Coraline's ear again.  Oh right, this one. (Just Coraline's ear again. At least she's still happy)
5/16/2009, 10:42:43 AM
Favs: 0
Retweets: 0
link


Thank you Alan for his amazing OSX Brew apache / php tutorial Follow me on Twitter to get more fun stuff: Wingsuitist
use your terminal:


public interface IQuery
There are two kinds of queries (and thus two kinds of query results):
FACTORY
constants, as defined by IItemQuery.FACTORY
and IDataQuery.FACTORY
. The generated query model provides type-safe
members for each path leading to all queryable attributes and references
defined on the Jazz component model types. Additionally, the query models and
associated members provide type-safe methods that represent query operations
that are valid for the given element. For example, an IString
represents a String query element, which has a valid operation
IString._eq(String)
. The result of that method creates an
IPredicate
which tests for equality. Note that all operations
available on the model elements are denoted with the leading "_";
this effectively separates the query operation from the queryable model
members.
Predicates are used to filter the result set returned by the query. Clients
set the predicate using the filter(IPredicate)
method.
Queries can be executed using the IQueryService.queryData
and
IQueryService.queryItems
service methods.
IItemQuery
,
IDataQuery
| Modifier and Type | Interface and Description |
|---|---|
static class |
IQuery.Factory<T extends IQuery,Q extends IQueryModel>
internal use only
|
| Modifier and Type | Method and Description |
|---|---|
IPredicate |
and(IPredicate p1,
IPredicate p2)
Returns a predicate that evaluates to true when both of the arguments
evalauate to true.
|
IQuery |
distinct()
Ensures each element in the query result is a distinct item handle
|
IQuery |
filter(IPredicate predicate)
Adds a filter to the requested query to reduce the results returned.
|
int |
getMaxQueryTime()
Returns the maximum amount of time, in milliseconds, that this query will
execute before being canceled.
|
boolean |
getQueryAgainstAllStreams()
Returns whether this query will find results in all streams
|
boolean |
getQueryAgainstAllStreamsAndBaselines() |
int |
getResultLimit()
Returns the limit on the number of rows that this query will
generate.
|
boolean |
isSameQuery(IQuery query)
Returns whether the given query is the same as this query.
|
INumericInputArg |
newBigDecimalArg()
Creates a new input argument slot in this query.
|
IBooleanInputArg |
newBooleanArg()
Creates a new input argument slot in this query.
|
IDateTimeInputArg |
newDateTimeArg()
Creates a new input argument slot in this query.
|
IEnumInputArg |
newEnumArg()
Creates a new input argument slot in this query.
|
INumericInputArg |
newIntegerArg()
Creates a new input argument slot in this query.
|
IItemHandleInputArg |
newItemHandleArg()
Creates a new input argument slot in this query.
|
IItemTypeInputArg |
newItemTypeArg()
Creates a new input argument slot in this query.
|
INumericInputArg |
newLongArg()
Creates a new input argument slot in this query.
|
IStringInputArg |
newStringArg()
Creates a new input argument slot in this query.
|
IUUIDInputArg |
newUUIDArg()
Creates a new input argument slot in this query.
|
IPredicate |
not(IPredicate p)
Returns a predicate that evaluates to true when the argument evalauates
to false.
|
IPredicate |
or(IPredicate p1,
IPredicate p2)
Returns a predicate that evaluates to true when either of the arguments
evalauate to true.
|
IQuery |
orderByAsc(IField aField)
Sorts the results of the query by the values for the queryable field, in
ascending order
|
IQuery |
orderByAsc(IStateExtensions ext,
IString key) |
IQuery |
orderByAsc(IStateExtensions ext,
java.lang.String key) |
IQuery |
orderByAscUsingLocale(IStateExtensions ext,
IString key) |
IQuery |
orderByAscUsingLocale(IStateExtensions ext,
java.lang.String key) |
IQuery |
orderByAscUsingLocale(IStringField aField)
Sorts the results of the query by the values for the queryable string field, in
ascending order using the client's language locale.
|
IQuery |
orderByDsc(IField aField)
Sorts the results of the query by the values for the queryable field, in
descending order
|
IQuery |
orderByDsc(IStateExtensions ext,
IString key) |
IQuery |
orderByDsc(IStateExtensions ext,
java.lang.String key) |
IQuery |
orderByDscUsingLocale(IStateExtensions ext,
IString key) |
IQuery |
orderByDscUsingLocale(IStateExtensions ext,
java.lang.String key) |
IQuery |
orderByDscUsingLocale(IStringField aField)
Sorts the results of the query by the values for the queryable string field, in
descending order using the client's language locale.
|
void |
setMaxQueryTime(int timeInMilliseconds)
Sets the maximum amount of time that the caller would like this query to
execute for.
|
void |
setQueryAgainstAllStreams(boolean value)
Sets whether this query should find results in all streams
|
void |
setQueryAgainstAllStreamsAndBaselines(boolean value)
In config aware mode, sets if this query finds results in all streams and
baselines, as opposed to the current configuration.
|
void |
setResultLimit(int resultLimit)
Sets the value of the
resultLimit attribute. |
IQuery distinct()
IPredicate and(IPredicate p1, IPredicate p2)
p1
- the first predicate to testp2
- the second predicate to testIPredicate or(IPredicate p1, IPredicate p2)
p1
- the first predicate to testp2
- the second predicate to testIPredicate not(IPredicate p)
p
- the predicate to testIQuery orderByAsc(IField aField)
aField
- a model field, acquired by traversing to an attribute from the
query model root.IQuery orderByAsc(IStateExtensions ext, java.lang.String key)
IQuery orderByAsc(IStateExtensions ext, IString key)
IQuery orderByAscUsingLocale(IStringField aField)
aField
- a model field, acquired by traversing to an attribute from the
query model root.IQuery orderByAscUsingLocale(IStateExtensions ext, java.lang.String key)
IQuery orderByAscUsingLocale(IStateExtensions ext, IString key)
IQuery orderByDsc(IField aField)
aField
- a model field, acquired by traversing to an attribute from the
query model root.IQuery orderByDsc(IStateExtensions ext, java.lang.String key)
IQuery orderByDsc(IStateExtensions ext, IString key)
IQuery orderByDscUsingLocale(IStringField aField)
aField
- a model field, acquired by traversing to an attribute from the
query model root.IQuery orderByDscUsingLocale(IStateExtensions ext, java.lang.String key)
IQuery orderByDscUsingLocale(IStateExtensions ext, IString key)
IStringInputArg newStringArg()
IQuery.new*Arg
methods. Input arguments created by this
query must only be used in filters for this query.INumericInputArg newIntegerArg()
IQuery.new*Arg
methods. Input arguments created by this
query must only be used in filters for this query.INumericInputArg newLongArg()
IQuery.new*Arg
methods. Input arguments created by this
query must only be used in filters for this query.INumericInputArg newBigDecimalArg()
IQuery.new*Arg
methods. Input arguments created by this
query must only be used in filters for this query.IBooleanInputArg newBooleanArg()
IQuery.new*Arg
methods. Input arguments created by this
query must only be used in filters for this query.IDateTimeInputArg newDateTimeArg()
IQuery.new*Arg
methods. Input arguments created by this
query must only be used in filters for this query.IUUIDInputArg newUUIDArg()
IQuery.new*Arg
methods. Input arguments created by this
query must only be used in filters for this query.IEnumInputArg newEnumArg()
IQuery.new*Arg
methods. Input arguments
created by this query must only be used in filters for this query.IItemHandleInputArg newItemHandleArg()
IItemHandle
instance
and must not be null. The order of the input args passed
into the query API must match the order in which the input args were
created using the IQuery.new*Arg
methods. Input arguments
created by this query must only be used in filters for this query.IItemTypeInputArg newItemTypeArg()
IQuery.new*Arg
methods. Input arguments
created by this query must only be used in filters for this query.IQuery filter(IPredicate predicate)
TeamQueryModel r = TeamQueryModel.ROOT; IItemQuery query = IItemQuery.FACTORY.newInstance(r); query.filter(r.name()._eq("Repo"));The predicate must be based on the same query model root that this query instance is based on. The following code is invalid because the query is based on
TeamQueryModel
and the filter is based on
ContributorQueryModel
:
IItemQuery query = IItemQuery.FACTORY.newInstance(TeamQueryModel.ROOT); query.filter(ContributorQueryModel.ROOT.name()._eq("Matt"));
predicate
- the predicate used to filter resultsboolean isSameQuery(IQuery query)
query
- a query to compare this query againstint getResultLimit()
void setResultLimit(int resultLimit)
resultLimit
attribute.
Negative values are not permitted.
Clients are advised to set a result limit if it is not reasonable to handle unlimited results. For example, if displaying to a user the results of a query, it may not make sense to display more than a few pages worth of results because most users won't want to see more than that. This does generally require a strategy to get additional pages for those few situations where more results are requested. For example, by sorting the results, it is possible to re-run the query with a filter that excludes the already presented results, and thus get the next page(s) of results.
resultLimit
- the new value of the resultLimit
attribute.int getMaxQueryTime()
void setMaxQueryTime(int timeInMilliseconds)
timeInMilliseconds
- the maximum time, in milliseconds, that this
query should execute before being canceled.getMaxQueryTime()
boolean getQueryAgainstAllStreams()
void setQueryAgainstAllStreams(boolean value)
value
- the value to setvoid setQueryAgainstAllStreamsAndBaselines(boolean value)
#setQueryAgainstAllStreams
(this takes precedence).value
- true to query against all streams and baselines.boolean getQueryAgainstAllStreamsAndBaselines()


DfE enquiries
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
Press release
Nick Gibb sets out plans for a commission to help improve primary school assessment and testing.
A new teacher-led commission will be set up to help primary schools as they move away from the ‘vague and imprecise’ system of levels for assessment - School Reform Minister Nick Gibb announced today (25 February 2015).
Speaking at an event hosted by think tank Reform , the minister said that assessment using levels - where pupils are grouped into broad bands from 1 to 8 - was misleading to parents and failed to ensure children acquired a good grasp of the basics.
As part of its plan for education, the Department for Education first announced that primary schools would be moving away from using level descriptors in 2013. Since then the department has been working with schools to support them as they develop their own assessment systems.
School Reform Minister Nick Gibb said:
Ensuring pupil assessment provides an accurate picture of a pupil’s attainment and progress without placing a bureaucratic burden on teachers is a key part of the government’s plan for education.
Levels have been a distracting, over-generalised label, giving misleading signals about the genuine attainment of pupils.
Crucially, they failed to give parents clarity over how their children were performing and also resulted in a lack of trust between primary and secondary schools - clogging up the education system with undependable data on pupil attainment.
The commission announced today will help schools develop their own, more accurate assessment systems that truly show how a child is performing in the classroom.
Level descriptors were only ever intended to be used to sum up a pupil’s attainment and progress at the end of 2 key stages (age 7 and 11 at primary school), however some schools had started to use them as a form of ongoing assessment.
The government wants to reduce central prescription and believes teachers should have the freedom to develop formative assessment systems that best fit the needs of their pupils. This approach will bring England in line with the top-performing countries and regions in the world, including Singapore and Hong Kong.
There are already examples of good practice where schools have developed their own systems which do not rely on levels, such as Westminster Academy in London, one of the winners of the Assessment Innovation Fund, and Wroxham Primary School in Potter’s Bar.
At Westminster Academy, teachers have broken down the curriculum into 15 topics which are each independently assessed via an in-class quiz, homework and an end-of-term exam. A score is produced for each topic and then used to provide an average score. Teachers then use topic scores to provide support where needed.
To help schools as they undertake these important changes and develop their own assessment schemes, the Department for Education is establishing a commission on assessment without levels .
This commission will continue the evidence-based approach to assessment that the government has already put in place, and will support primary and secondary schools with the transition to assessment without levels, identifying and sharing good practice in assessment. The commission will be chaired by John McIntosh, a member of the National Curriculum Review Advisory Committee and former headmaster of the London Oratory School.
In his speech, the minister also said the models for measuring progress led to a narrow focus on getting pupils over boundaries - at level 4, at age 11, and at grade C or above at GCSE .
In his speech, School Reform Minister Nick Gibb said:
The education system lost sight of the need for a genuine conversation between parents and schools to help parents support their children - on this part of reading or that part of maths - rather than focusing on a blanket judgment.
In short, levels were just too vague and imprecise. They were misleading as to what pupils knew and could do. The use of levels was pushing pupils on to new material - in the name of ‘pace’ - when they had not adequately understood vital content, and had serious gaps in their knowledge.
We had a system swimming in defective data on attainment and failed to see that our legal commitment to giving all children access to all of the national curriculum had been compromised.
The government announced the use of level descriptors would end in 2013. The new national curriculum was introduced in September 2014. National curriculum test sample materials for the tests of the new national curriculum will be made available to schools in June 2015.
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
Published: 25 February 2015


Before Change
f"{v1_goals}`. (You must explicitly enumerate every file because " f"`--owner-of` does "
f"not support globs.)"
)
raise FilesystemSpecsUnsupported(
f"Instead of running `{approximate_original_command}`, {suggestion}\n\n"
f"Why? Filesystem specs like `src/python/example.py` and `src/**/*.java` (currently) only "
f"work when running goals implemented with the V2 engine. When using V1 goals, either use "
f"traditional address specs like `src/python/example:foo` and `::` or use `--owner-of` "
f"for Pants to find the file"s owning target(s) for you.\n\n"
f"(You may find which goals are implemented in V1 by running `{pants_bin_name} --v1 --no-v2 "
f"goals` and find V2 goals by running `{pants_bin_name} --no-v1 --v2 goals`.)"
)
def _determine_v1_goals(self, options: Options) -> List[Goal]:
Check and populate the requested goals for a given run.
v1_goals, ambiguous_goals, _ = options.goals_by_version
After Change
BuildFileAddresses, [self._specs.filesystem_specs]
)
updated_address_specs = AddressSpecs(
dependencies=tuple(
SingleAddress(a.spec_path, a.target_name) for a in owned_addresses
),
tags=self._specs.address_specs.matcher.tags,
exclude_patterns=self._specs.address_specs.matcher.exclude_patterns,
)
self._specs = Specs(
address_specs=updated_address_specs,
filesystem_specs=FilesystemSpecs([]),
)
def _determine_v1_goals(self, options: Options) -> List[Goal]:
Check and populate the requested goals for a given run.
v1_goals, ambiguous_goals, _ = options.goals_by_version


Button primary small
{{> button _label="Primary small" _type="primary" _size="small" _leftIcon="" _rightIcon="" }}Button primary medium
{{> button _label="Primary medium" _type="primary" _size="medium" _leftIcon="" _rightIcon="" }}Button primary DEFAULT
{{> button _label="Primary" _type="primary" _leftIcon="" _rightIcon="" }}This is super h1
This is h1
This is H2
This is H3
This is H4
This is H5
This is H6
This is p1
This is p2.
This is p3.
This is a Label.