In this project I complete the implementation of a simplified Tetris-style or “falling blocks” type of video game. This particular game, which we’ll call MagicTetris, is a variation of Tetris. The basic idea is as follows. The game is played on a 2D grid. Each position in this grid can be represented as a (row, column) pair. At any stage in the game, a grid position may be empty or may be occupied by a block. In addition, a shape made up of a combination of blocks (often called a tetromino), falls from the top of the grid. This is referred to as the current shape. As it falls, the current shape can be
When the currently falling shape can’t fall any further, its blocks are added to the grid, and the game checks whether it has completed a row (or more generally, a collapsible set). All blocks in a collapsible set are then removed from the grid, and blocks above them are shifted down an equivalent amount. A block may also be "magic", which works like this: When a row is completed that contains at least three magic blocks (shown below, left, with a white dot on them), then in addition to collapsing the completed rows, the game momentarily goes into gravity mode. In the next step of the game, all blocks with empty cells below them are allowed to “fall” independently.


Using nix-shell as package manager for any language
Disclaimer!
Software development
Software design and development is a very complicated process. It is a set of related activities that let to the production of an application or software. Those activites may involve the development of the software from scratch or a more tidious process of modyfiying an existing system.
Software might be the first kind of knowledge that can be composed. It is hard to develop, but it is often easy to use, and is not even that hard to combine. And the latter is what brings the real magic. It is the closest thing to “building on the shoulders of giants” in the realm of really building stuff.
Dependencies
A good practice in software design is to build software from smaller, single-purpose modules that exposes well-defined interfaces. This is also in the spirit of software reuse. With the widespread adoption of open source software, often applications or modules depend on other applications and modules. Thus, to build an application we need to bring in all parts on which it depends, including language libraries and remote third-party modules.
so:
thus:
- All software exists in a graph of dependencies.
- Most of the time, this graph is implicit.

Sharing commonly-used code in the form of libraries is one of the key aspects of software development. Ease of sharing code libraries combined with easy discovery build ecosystems is one of the greates value for an ecosystem to be successfully be that a programming language or a framework. There are many good examples like: NodeJS’s npm, Rust’s crates, Python’s PyPI among many of them.
The big problem is the fact that small even the smallest libraries pull in additional depedencies on which they rely in order to avoid too much code duplication And as those packages or modules or libraries increases in adoption, they get bundled in more and more packages. While this is a nice thing to have, the flip side is that we see multiple levels of dependencies build up as these packages are in turn used by others and those by others.
The trap
Lets just describe a very simple dependency hell [credits goes to this guy]:
The App
We have a deployable application A
, that depends on j-1.0
and k-1.0
which in turn depends on d-1.0
and there is only one version of everything and all projects live in their own version control.
The Trap
Now we have an a new version of j-2.0
added to the system that depends on a new version of d-2.0
. As application A
does not use the new version of j-2.0
but still uses j-1.0
, everything is still working fine.
The Trouble
The application A
developer now wants to use the latest version of j-2.0
as it has some great performance improvements. However we now have a problem as j-2.0
depends on d-2.0
and k-1.0
depends on d-1.0
but only one version of d
can be used.
 The example above is what is calld a diamond dependency. According to Wikipedia there are 6 kind of hell (sorry Dante):
- Many dependencies
- Long chains of dependencies
- Conflicting dependencies
- Circular dependencies
- Package manager dependencies
- Diamond dependency
So what now??
But it’s not trivial to ensure that we have all necessary dependencies, particularly when dependencies themselves depend on others. This is why we need a Dependency Manager.
Dependency managers bring together all necessary project dependencies before passing them to the compiler or interpreter. In this sense, their work is somewhat a preprocessing phase before the actual build happens.
Enter NIX
It’s difficult to categorize Nix. On the website, it is presented as a “purely functional package manager”. However, it could also be thought of as a programming language, a configuration tool, and a build tool. In a nutshell, Nix expressions are programs written in a purely functional programming language and can return a single derivation or a set of derivations.
This difficulty to categorize comes due to a few different projects sharing similar names.
- NixOS: an operating system that uses the power of Nix and Nix expressions to provide system configuration management.
- Nix-pkgs: the common repository of software that defines how to install rust, go, vim, pip, etc.
- Nix-shell: starts an interactive shell based on a Nix expression that either builds or fetches cached builds of dependencies and adds them to the Nix store.
- Nix-store: is the path where immutable build packages are stored. Since every build/version has its own path, packages are atomic.
The key take-away of NIS it’s deterministic and reproducable builds. Meaning that, given some Nix-expression, it doesn’t matter on what computer or what time you attempt to build it, it will produce the same result. Nix has gone to great lengths to ensure reproducible builds, where not just the project’s direct dependencies are locked, but practically every external dependency up to and including the global system. It formalizes and encapsulates these tools in a way that they are locked to a given version.


0
mph
Requesting GPS Location...
[
] lat:
lon:
accuracy:
m speed:
Settings
Units
metric
imperial
Debug
Review this app
Send feedback (email)


PUBG Corp. overestimated its own playerbase, it seems
by Oscar DayusPUBG developer PUBG Corp. has overestimated either the size or commitment of its own playerbase, it seems, as it has been forced to revise some community mission targets downwards.
The latest PUBG Miramar update introduced a mission that tasked the entire PUBG community with collecting 1.95 million DVDs in-game, with the tantalising prize of Miramar lore and the Hexadeathimal level two helmet on offer. However, according to PUBG dataminer PlayerIGN, the developer has been forced to downgrade that target – presumably because it overestimated its audience.
It was believed that players were enthused by the challenge at first, trying to find the elusive old DVDs that awarded three points. But the downgraded amount suggests the enthusiasm became frustration in relatively short order. As you can see in the tweet below, the helmet now has the target of 1.3 million DVDs. I guess people just watch films on Netflix now, huh.
In other PUBG news, the game is dropping the use of locked loot boxes as “players do not get enjoyment out of opening crates”.
The game also has a Riot Shield, new weapons, and more on the way, if a leak is to be believed.
Elsewhere, the inaugural PUBG Global Championship occurred over the weekend, seeing Gen.G take home first place. There’s been some concerns over the future of competitive play recently, with a rescinded deal for exclusive skins right before the PGC. At the very least, this first year seemed to go off without a hitch, so hopefully some doubts were quelled.


--- layout: post title: 'Darren on Flex: Overloading the Constructor' date: '2008-09-21T11:45:00.001+01:00' author: Darren Bishop tags: - Flex - ActionScript - TDD - Personal Thoughts - Testing modified_time: '2008-09-21T11:49:54.651+01:00' blogger_id: tag:blogger.com,1999:blog-3826577489563855618.post-891141856223849476 blogger_orig_url: http://blog.darrenbishop.com/2008/09/darren-on-flex-overloading-constructor.html ---
public function DefaultValueExample(required:String, andTheCommonCase:String="DEFAULT") { if (!required) { throw new ArgumentError("You must specify required arguments"); } // construct something with the required value andTheCommonCase }Obviously the API designer needs to know the complete set of parameters, that is, those that must be specified and those that can have a default values. So far my references to the common-case are just to the concept of it, a place holder. The common-case represents the design challenge in using this language feature while, simultaneously, it represents the design limitation; the common-case(s) is prescribed to all the API clients irrespective of client needs. However, in practice the common-case is not a difficult trade-off to figure out and tends to be only a minor inconvenience. For example, in my experience, such cases tend to crop up during unit testing, which I anticipate will be less of a problem with TDD (yes, I am still homing my skills with TDD on Flex/AS3).
public function VarArgExample(... args) { for each (var arg:* in args) { // process arg... } //... then do construction }I reckon this has less application than default parameters as it only makes-sense/works when the (signature of the) things you are using during construction have parameters of no-type (
*
or Object
) or a common super-type. Then you can either leverage duck-typing or polymorphism, respectively, to do smart things, which I won't discuss here.
XxxFactory
's getInstance()
, newInstances()
and createInstance()
cruft and adopt something more revealing?
//Person.as public class Person { public function Person(firstName:String="", lastName:String="", ... middleNames) { // do somthing } } //PersonFactory.as public class PersonFactory { public function newPersonWithFirstName(firstname:String):Person { return new Person(firstname); } public function newPersonWithLastName(lastname:String):Person { return new Person(null, lastname); } // A little inconvenient public function newPersonWithFirstAndLastName(firstname:String, lastname:String):Person { return new Person(firstname, lastname); } }So what's the runtime overhead? Just the extra
PersonFactory
class, where the would-be constructor overloads are replaced with simple methods; let's face it, negligible.
And the API overhead? Well interestingly, a problem has emerged and a pattern has been used to solve it. Furthermore, our intention revealing names should improve readability of the code and identifies a good place to refactor/relocate creational code that gets used over and over again... like, for instance, in your tests.
Comments welcome.


A Simple Dropdown Menu
Home
Services
Web Design
Web Development
Web Hosting
About
Our Company
Our Team
Our Reach
Blog
Contact


Hello there!
I am Samriddha. You can call me Sam. Welcome to my personal website and blog!
You can learn more about me here
To see some of my projects, head over here.
This website is not regularly updated and is due for a revamp, but feel free to contact me with suggestions by pressing the red floating action button to the lower right.


Property change events are dispatched after the property change was
validated on the server.
name:String
[read-only]
Get the name of the property that changed.
Implementation
public function get name():String
newValue:Object
[read-only]
Get the property's new value.
Note: if index is not -1 then this value is merely one element in an array that
may be fully accessed using the 'net' subcontrol.
Implementation
public function get newValue():Object
oldValue:Object
[read-only]
Get the property's previous value (handy!).
Implementation
public function get oldValue():Object
public function PropertyChangedEvent(type:String, propName:String, newValue:Object, oldValue:Object)
Constructor.
Parameters
| type:String |
| |
| propName:String |
| |
| newValue:Object |
| |
| oldValue:Object |
public override function clone():Event
Returns
public override function toString():String
Returns
public static const PROPERTY_CHANGED:String = "PropChanged"
The type of a property change event.
Copyright © 2007-2009 Three Rings Design, Inc.


Documentation for WISC loss and risk model¶
A simple ReadtheDocs reference guide to all functions used to estimate losses per building type due to Windstorms in Europe.
Note that the explanation of the functions in this reference guide is mainly focused on the explanation of the inputs and outputs. Please refer to the source code for a step-by-step explanation of the code.
- Getting started
- Utils
- Functions
- Regional exposure
- Regional losses
- Regional sensitivity analysis
- Loss calculation
- Fetch buildings from OpenStreetMap
- Create .poly files
- Extract buildings from OpenStreetMap
- Convert buildings table from EPSG:4326 to EPSG:3035
- Build list of storms
- Build list of storms for event set
- Load storms for sensitivity analysis
- Load table of maximum damages
- Load fragility curves
- Load curves ratios
- Load OpenStreetMap data
- Clip landuse
- Clip OpenStreetMap file
- Obtain raster value from geotiff grid
- Create excel file with summary statistics
- Analyze
- Sensitivity Analysis
- Plotting


Javascript Labs
Search for a string inside another string
Please enter the string you wish to search
Please enter the search string
Please click here to search for a string within a string using the SLICE() method
Please click here to search for a string using the indexOf() method
Please click here to find the index of the last occurrence of the search string using the lastIndexOf() method


This page may not exist or may be removed
OR
This page is under construction!
We will serve you as soon as possible
Go to Home page


 George Malley reprises the role of the lovable common guy, except this one walks out into the night on his birthday, stares at the sky and the brain explodes into activity, and his life is never the same again.
John Travolta plays George Malley, a mechanic whose idea of wooing his lady love, Lace (Kyra Sedgwick), a really bad chair maker, is to buy the chairs she makes, just so she will make more chairs and keep coming back to the stand outside his garage where they are put for sale. He even gives them to his best friend, as he has so many chairs he doesn't know what to do with them. *gush* After he gets zapped by the light in the sky his brain is so energised he reads two or three books a day, learns Portuguese in 20 minutes, predicts earthquakes and experiments with solar energy.
His long-time doctor (Robert Duvall) and conscience of the town tries to goad him for a medical checkup, as all this brain activity is so (duh) unusual, but of course George refuses till its too late. The ending is quire predictable once you realise why hes suddenly become so smart. The plot kind of falls apart from that point onwards.
Apart from being thoroughly impossible in a realistic setting, it fails because the characters take far too long to get going. Most of the film is spent in trying to wow us with the new-found prowess of Georges brain.   HOW??!! They never tell us!
Travolta's role as a SNAG (sensitive New Age guy) is a mark of how versatile an actor he is, and that his success as a Ah Beng exterminator in PULP FICTION wasn't just a one-off comeback. It is a shame, however, that he does not get to exhibit much of an acting range in this soppy tear-jerker. Also, Robert Duvall spends most of his time looking rather perturbed, as he ponders the mysteries of George's brain and acts as his surrogate father. Very two-dimensional characters here.
But, as the trend goes in movies nowadays (cf. A TIME TO KILL, THE HUNCHBACK OF NOTRE DAME, FORREST GUMP) the issue of prejudicing those who are different from us is addressed. Rather than accepting George's change, the townsfolk are crude and critical - they make up stories about how he had probably seen a UFO and maybe the aliens altered his brain, as well as media-bashing the insensitive press. Makes a point, thought rather un-subtly.
The Flying Inkpot Rating System: * Wait for the TV2 broadcast. ** A little creaky, but still better than staying at home with Gotcha! *** Pretty good, bring a friend. **** Amazing, potent stuff. ***** Perfection. See it twice.
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


Add a wallet
With this page you can link a wallet to a portfolio.
Return to details
Return to list
Add wallet
Coin
-Select coin-
symbol (name)
Portfolio
-Select portfolio-
name
Wallet address
Description
Update


{% extends "layout.html" %} {% block content %}
Please, try again with correct version of your email and pin


Reports anonymous inner classes with too high of a total complexity. The
total complexity of a class is the sum of the cyclomatic complexities of all the methods
and initializers the class declares. Inherited methods and initializers are not counted
toward the total complexity. Anonymous classes with more than very low complexities may be
difficult to understand, and should probably be promoted to become named inner classes.
Use the field below to specify the maximum complexity a class is allowed to have.
Powered by InspectionGadgets


Recipe 7.10. Storing a BLOB in a MySQL DatabaseCredit: Luther Blissett ProblemYou need to store a binary large object (BLOB) in a MySQL database. SolutionThe MySQLdb module does not support full-fledged placeholders, but you can make do with the module's escape_string function: import MySQLdb, cPickle # Connect to a DB, e.g., the test DB on your localhost, and get a cursor connection = MySQLdb.connect(db="test") cursor = connection.cursor( ) # Make a new table for experimentation cursor.execute("CREATE TABLE justatest (name TEXT, ablob BLOB)") try: # Prepare some BLOBs to insert in the table names = 'aramis', 'athos', 'porthos' data = { } for name in names: datum = list(name) datum.sort( ) data[name] = cPickle.dumps(datum, 2) # Perform the insertions sql = "INSERT INTO justatest VALUES(%s, %s)" for name in names: cursor.execute(sql, (name, MySQLdb.escape_string(data[name])) ) # Recover the data so you can check back sql = "SELECT name, ablob FROM justatest ORDER BY name" cursor.execute(sql) for name, blob in cursor.fetchall( ): print name, cPickle.loads(blob), cPickle.loads(data[name]) finally: # Done. Remove the table and close the connection. cursor.execute("DROP TABLE justatest") connection.close( ) DiscussionMySQL supports binary data (BLOBs and variations thereof), but you should be careful when communicating such data via SQL. Specifically, when you use a normal INSERT SQL statement and need to have binary strings among the VALUES you're inserting, you have to escape some characters in the binary string according to MySQL's own rules. Fortunately, you don't have to figure out those rules for yourself: MySQL supplies a function that does the needed escaping, and MySQLdb exposes it to your Python programs as the escape_string function. This recipe shows a typical case: the BLOBs you're inserting come from cPickle.dumps, so they may represent almost arbitrary Python objects (although, in this case, we're just using them for a few lists of characters). The recipe is purely demonstrative and works by creating a table and dropping it at the end (using a try/finally statement to ensure that finalization is performed even if the program should terminate because of an uncaught exception). With recent versions of MySQL and MySQLdb, you don't even need to call the escape_string function anymore, so you can change the relevant statement to the simpler: cursor.execute(sql, (name, data[name])) See AlsoRecipe 7.11 and Recipe 7.12 for PostgreSQL-oriented and SQLite-oriented solutions to the same problem; the MySQL home page (http://www.mysql.org); the Python/MySQL interface module (http://sourceforge.net/projects/mysql-python). |


In an amazingly enlightening conversation, Naval Ravikant, the CEO of AngelList, and Ryan Shea, Co-founder of Blockstack, share thoughts on decentralization – how we are going from having too many expensive middlemen to fewer less expensive middlemen (Uber, Lyft), to having no middlemen at all (DLT), and how ICOs are mostly a bad cost of technology adoption in the long run.
A conversation with Naval Ravikant & Ryan Shea, Blockstack Summit 2017


Archived release notes¶
sd (04/06/2018)¶
New: Additional variable (names) “getter”-like and resolver methods
DataSet.created()
DataSet.find(str_tags=None, suffixed=False)
DataSet.names()
DataSet.resolve_name()
A bunch of new methods enhancing the options of finding and testing for variable
names have been added. created()
will list all variables that have been added
to a dataset using core functions, i.e. add_meta()
and derive()
, resp.
all helper methods that use them internally (as band()
or categorize()
do
for instance).
The find()
method is returning all variable names that contain any of the
provided substrings in str_tags
. To only consider names that end with these
strings, set suffixed=True
. If no str_tags
are passed, the method will
use a default list of tags including ['_rc', '_net', ' (categories', ' (NET', '_rec']
.
Sometimes a dataset might contain “semi-duplicated” names, variables that differ
in respect to case sensitivity but have otherwise identical names. Calling
names()
will report such cases in a pd.DataFrame
that lists all name
variants under the respective str.lower()
version. If no semi-duplicates
are found, names()
will simply return DataSet.variables()
.
Lastly, resolve_name()
can be used to return the “proper”, existing representation(s) of a given variable name’s spelling.
New: Batch.remove()
Not needed batches can be removed from meta
, so they are not aggregated
anymore.
New: Batch.rename(new_name)
Sometimes standard batches have long/ complex names. They can now be changed into a custom name. Please take into account, that for most hubs the name of omnibus batches should look like ‘client ~ topic’.
Update: Handling verbatims in qp.Batch
Instead of holding the well prepared open-end dataframe in batch.verbatims
,
the attribute is now filled by batch.add_open_ends()
with instructions to
create the open-end dataframe. It is easier to to modify/ overwrite existing
verbatims. Therefore also a new parameter is included overwrite=True
.
Update: Batch.copy(..., b_filter=None, as_addition=False)
It is now possible to define an additional filter for a copied batch and also to set it as addition to the master batch.
Update: Regrouping the variable list using DataSet.order(..., regroup=True)
A new parameter called regroup
will instruct reordering all newly created
variables into their logical position of the dataset’s main variable order, i.e.
attempting to place derived variables after the originating ones.
Bugfix: add_meta()
and duplicated categorical values
codes
Providing duplicated numerical codes while attempting to create new metadata
using add_meta()
will now correctly raise a ValueError
to prevent
corrupting the DataSet
.
>>> cats = [(1, 'A'), (2, 'B'), (3, 'C'), (3, 'D'), (2, 'AA')]
>>> dataset.add_meta('test_var', 'single', 'test label', cats)
ValueError: Cannot resolve category definition due to code duplicates: [2, 3]
sd (04/04/2018)¶
New: Emptiness handlers in DataSet
and Batch
classes
DataSet.empty(name, condition=None)
DataSet.empty_items(name, condition=None, by_name=True)
DataSet.hide_empty_items(condition=None, arrays=None)
Batch.hide_empty(xks=True, summaries=True)
empty()
is used to test if regular variables are completely empty,
empty_items()
checks the same for the items of an array mask definition.
Both can be run on lists of variables. If a single variable is tested, the former
returns simply boolean, the latter will list all empty items. If lists are checked,
empty()
returns the sublist of empty variables, empty_items()
is mapping
the list of empty items per array name. The condition
parameter of these
methods takes a Quantipy logic
expression to restrict the test to a subset
of the data, i.e. to check if variables will be empty if the dataset is filtered
a certain way. A very simple example:
>>> dataset.add_meta('test_var', 'int', 'Variable is empty')
>>> dataset.empty('test_var')
True
>>> dataset[dataset.take({'gender': 1}), 'test_var'] = 1
>>> dataset.empty('test_var')
False
>>> dataset.empty('test_var', {'gender': 2})
True
The DataSet
method hide_empty_items()
uses the emptiness tests to
automatically apply a hiding rule on all empty items found in the dataset.
To restrict this to specific arrays only, their names can be provided via the
arrays
argument. Batch.hide_empty()
takes into account the current
Batch.filter
setup and by drops/hides all relevant empty variables from the
xks
list and summary aggregations by default. Summaries that would end up without valid
items because of this are automatically removed from the summaries
collection
and the user is warned.
New: qp.set_option('fast_stack_filters', True)
A new option to enable a more efficient test for already existing filters
inside the qp.Stack
object has been added. Set the 'fast_stack_filters'
option to True
to use it, the default is False
to ensure compatibility
in different versions of production DP template workspaces.
Update: Stack.add_stats(..., factor_labels=True, ...)
The parameter factor_labels
is now also able to take the string '()'
,
then factors are written in the normal brackets next to the label (instead
of []
).
In the new version factor_labels are also just added if there are none included before, except new scales are used.
Bugfix: DataSet
np.NaN
insertion to delimited_set
variables
np.NaN
was incorrectly transformed when inserted into delimited_set
before, leading to either numpy
type conflicts or type casting exceptions.
This is now fixed.
sd (27/02/2018)¶
New: DataSet._dimensions_suffix
DataSet
has a new attribute _dimensions_suffix
, which is used as mask
suffix while running DataSet.dimensionize()
. The default is _grid
and
it can be modified with DataSet.set_dim_suffix()
.
Update: Stack._get_chain()
(old chain)
The method is speeded-up. If a filter is already included in the Stack, it is
not calculated from scratch anymore. Additionally the method has a new parameter
described
, which takes a describing dataframe of the Stack, so it no longer
needs to be calculated in each loop.
Nets that are applied on array variables will now also create a new recoded
array that reflects the net definitions if recoded
is used. The
method has been creating only the item versions before.
Update: Stack.add_stats()
The method will now create a new metadata property called 'factor'
for each
variable it is applied on. You can only have one factor assigned to one
categorical value, so for multiple statistic definitions (exclusions, etc.)
it will get overwritten.
Update: DataSet.from_batch()
(additions
parameter)
The additions
parameter has been updated to also be able to create recoded
variables from existing “additional” Batches that are attached to a parent one.
Filter variables will get the new meta 'properties'
tag 'recoded_filter'
and only have one category (1
, 'active'
). They are named simply
'filter_1'
, 'filter_2'
and so on. The new possible values of the
parameters are now:
None
:as_addition()
-Batches are not considered.'variables'
: Only cross- and downbreak variables are considered.'filters'
: Only filters are recoded.'full'
:'variables'
+'filters'
Bugfix: ViewManager._request_views()
Cumulative sums are only requested if they are included in the belonging
Stack
. Additionally the correct related sig-tests are now taken for
cumulative sums.
sd (12/01/2018)¶
New: Audit
Audit
is a new class which takes DataSet
instances, compares and aligns
them.
The class compares/ reports/ aligns the following aspects:
- datasets are valid (
DataSet.validate()
)- mismatches (variables are not included in all datasets)
- different types (variables are in more than one dataset, but have different types)
- labels (variables are in more than one dataset, but have different labels for the same text_key)
- value codes (variables are in more than one dataset, but have different value codes)
- value texts (variables are in more than one dataset, but have different value texts)
- array items (arrays are in more than one dataset, but have different items)
- item labels (arrays are in more than one dataset, but their items have different labels)
This is the first draft of the class, so it will need some testing and probably adjustments.
New: DataSet.reorder_items(name, new_order)
The new method reorders the items of the included array. The ints in the
new_order
list match up to the number of the items
(DataSet.item_no('item_name')
), not to the position.
New: DataSet.valid_tks
, Arabic
Arabic (ar-AR
) is included as default valid text-key.
New: DataSet.extend_items(name, ext_items, text_key=None)
The new method extends the items of an existing array.
Update: DataSet.set_missings()
The method is now limited to DataSet
, Batch
does not inherit it.
Update: DataSet
The whole class is reordered and cleaned up. Some new deprecation warnings will appear.
Update: DataSet.add_meta()
/ DataSet.derive()
Both methods will now raise a ValueError: Duplicated codes provided. Value codes must be unique!
if categorical values
definitions try to apply duplicated codes.
sd (18/12/2017)¶
New: Batch.remove_filter()
Removes all defined (global + extended) filters from a Batch instance.
Update: Batch.add_filter()
It’s now possible to extend the global filter of a Batch instance. These options are possible.
Add first filter:
>>> batch.filter, batch.filter_names
'no_filter', ['no_filter']
>>> batch.add_filter('filter1', logic1)
>>> batch.filter, batch.filter_names
{'filter1': logic1}, ['filter1']
Extend filter:
>>> batch.filter, batch.filter_names
{'filter1': logic}, ['filter1']
>>> batch.add_filter('filter2', logic2)
>>> batch.filter, batch.filter_names
{'filter1' + 'filter2': intersection([logic1, logic2])}, ['filter1' + 'filter2']
Replace filter:
>>> batch.filter, batch.filter_names
{'filter1': logic}, ['filter1']
>>> batch.add_filter('filter1', logic2)
>>> batch.filter, batch.filter_names
{'filter1': logic2}, ['filter1']
Update: Stack.add_stats(..., recode)
The new parameter recode
defines if a new numerical variable is created which
satisfies the stat definitions.
Update: DataSet.populate()
A progress tracker is added to this method.
Bugfix: Batch.add_open_ends()
=
is removed from all responsess in the included variables, as it causes
errors in the Excel-Painter.
Bugfix: Batch.extend_x()
and Batch.extend_y()
Check if included variables exist and unroll included masks.
Bugfix: Stack.add_nets(..., calc)
If the operator in calc is div
/ /
, the calculation is now performed
correctly.
sd (28/11/2017)¶
New DataSet.from_batch()
Creates a new DataSet
instance out of Batch
definitions (xks, yks,
filter, weight, language, additions, edits).
New: Batch.add_total()
Defines if total column @
should be included in the downbreaks (yks).
New: Batch.set_unwgt_counts()
If cellitems are cp
and a weight is provided, it is possible to request
unweighted count views (percentages are still weighted).
Update: Batch.add_y_on_y(name, y_filter=None, main_filter='extend')
Multiple y_on_y
aggregations can now be added to a Batch
instance
and each can have an own filter. The y_on_y-filter can extend
or replace
the main_filter of the Batch
.
Update: Stack.add_nets(..., recode)
The new parameter recode
defines if a new variable is created which
satisfies the net definitions. Different options for recode
are:
'extend_codes'
: The new variable contains all codes of the original variable and all nets as new categories.'drop_codes'
: The new variable contains only all nets as new categories.'collect_codes'
or'collect_codes@cat_name'
: The new variable contains all nets as new categories and another new category which sums all cases that are not in any net. The new category text can be defined by adding@cat_name
tocollect_codes
. If none is providedOther
is used as default.
Update: Stack.add_nets()
If a variable in the Stack
already has a net_view, it gets overwritten
if a new net is added.
Update: DataSet.set_missings(..., missing_map)
The parameter missing_map
can also handle lists now. All included
codes are be flagged as 'exclude'
.
Update: request_views(..., sums='mid')
(ViewManager
/query.py
)
Allow different positions for sums in the view-order. They can be placed in
the middle ('mid'
) between the basics/ nets and the stats or at the
'bottom'
after the stats.
Update/ New: write_dimensions()
Converting qp data to mdd and ddf files by using write_dimensions()
is
updated now. A bug regarding encoding texts is fixed and additionally all
included text_keys
in the meta are transferred into the mdd. Therefore
two new classes are included: DimLabels
and DimLabel
.
sd (13/11/2017)¶
- New ``DataSet.to_delimited_set(name, label, variables,
- from_dichotomous=True, codes_from_name=True)``
Creates a new delimited set variable out of other variables. If the input-
variables are dichotomous (from_dichotomous
), the new value-codes can be
taken from the variable-names or from the order of the variables
(codes_from_name
).
Update Stack.aggregate(..., bases={})
A dictionary in form of:
bases = {
'cbase': {
'wgt': True,
'unwgt': False},
'cbase_gross': {
'wgt': True,
'unwgt': True},
'ebase': {
'wgt': False,
'unwgt': False}
}
defines what kind of bases will be aggregated. If bases
is provided the
old parameter unweighted_base
and any bases in the parameter views
will be ignored. If bases is not provided and any base is included in views
,
a dictionary is automatically created out of views
and unweighted_base
.
sd (17/10/2017)¶
New: del DataSet['var_name']
and 'var_name' in DataSet
syntax support
It is now possible to test membership of a variable name simply using the in
operator instead of DataSet.var_exists('var_name')
and delete a variable definition
from DataSet
using the del
keyword inplace of the drop('var_name')
method.
New: DataSet.is_single(name)
, .is_delimited_set(name)
, .is_int(name)
, .is_float(name)
, .is_string(name)
, .is_date(name)
, .is_array(name)
These new methods make testing a variable’s type easy.
Update: DataSet.singles(array_items=True)
and all other non-array
type iterators
It is now possible to exclude array
items from singles()
, delimited_sets()
,
ints()
and floats()
variable lists by setting the new array_items
parameter to False
.
Update: Batch.set_sigtests(..., flags=None, test_total=None)
, Batch.sigproperties
The significancetest-settings for flagging and testing against total, can now
be modified by the two parameters flags
and test_total
. The Batch
attribute siglevels
is removed, instead all sig-settings are stored
in Batch.sigproperties
.
Update: Batch.make_summaries(..., exclusive=False)
, Batch.skip_items
The new parameter exclusive
can take a list of arrays or a boolean. If a list
is included, these arrays are added to Batch.skip_items
, if it is True all
variables from Batch.summaries
are added to Batch.skip_items
Update: quantipy.sandbox.sandbox.Chain.paint(..., totalize=True)
If totalize
is True
, @
-Total columns of a (x-oriented) Chain.dataframe
will be painted as 'Total'
instead of showing the corresponsing x
-variables
question text.
Update: quantipy.core.weights.Rim.Rake
The weighting algorithm’s generate_report()
method can be caught up in a
MemoryError
for complex weight schemes run on very large sample sizes. This
is now prevented to ensure the weight factors are computed with priority and
the algorithm is able to terminate correctly. A warning is raised:
UserWarning: OOM: Could not finish writing report...
Update: Batch.replace_y()
Conditional replacements of y-variables of a Batch
will now always also
automatically add the @
-Total indicator if not provided.
Bugfix: DataSet.force_texts(..., overwrite=True)
Forced overwriting of existing text_key
meta data was failing for array
mask
objects. This is now solved.
sd (15/09/2017)¶
New: DataSet.meta_to_json(key=None, collection=None)
The new method allows saving parts of the metadata as a json file. The parameters
key
and collection
define the metaobject which will be saved.
New: DataSet.save()
and DataSet.revert()
These two new methods are useful in interactive sessions like Ipython or
Jupyter notebooks. save()
will make a temporary (only im memory, not
written to disk) copy of the DataSet
and store its current state. You can
then use revert()
to rollback to that snapshot of the data at a later
stage (e.g. a complex recode operation went wrong, reloading from the physical files takes
too long…).
New: DataSet.by_type(types=None)
The by_type()
method is replacing the soon to be deprecated implementation
of variables()
(see below). It provides the same functionality
(pd.DataFrame
summary of variable types) as the latter.
Update: DataSet.variables()
absorbs list_variables()
and variables_from_set()
In conjunction with the addition of by_type()
, variables()
is
replacing the related list_variables()
and variables_from_set()
methods in order to offer a unified solution for querying the DataSet
’s (main) variable collection.
Update: Batch.as_addition()
The possibility to add multiple cell item iterations of one Batch
definition
via that method has been reintroduced (it was working by accident in previous
versions with subtle side effects and then removed). Have fun!
Update: Batch.add_open_ends()
The method will now raise an Exception
if called on a Batch
that has
been added to a parent one via as_addition()
to warn the user and prevent
errors at the build stage:
NotImplementedError: Cannot add open end DataFrames to as_addition()-Batches!
sd (31/08/2017)¶
New: DataSet.code_from_label(..., exact=True)
The new parameter exact
is implemented. If exact=True
codes are returned
whose belonging label is equal the included text_label
. Otherwise the
method checks if the labels contain the included text_label
.
New: DataSet.order(new_order=None, reposition=None)
This new method can be used to change the global order of the DataSet
variables. You can either pass a complete new_order
list of variable names to
set the order or provide a list of dictionaries to move (multiple) variables
before a reference variable name. The order is reflected in the case data
pd.DataFrame.columns
order and the meta 'data file'
set
object’s items.
New: DataSet.dichotomize(name, value_texts=None, keep_variable_text=True, ignore=None, replace=False, text_key=None)
Use this to convert a 'delimited set'
variable into a set of binary coded
'single'
variables. Variables will have the values 1/0 and by default use
'Yes'
/ 'No'
as the corresponding labels. Use the value_texts
parameter to apply custom labels.
New: Batch.extend_x(ext_xks)
The new method enables an easy extension of Batch.xks
. In ext_xks
included str
are added at the end of Batch.xks
. Values of included
dict
s are positioned in front of the related key.
Update: Batch.extend_y(ext_yks, ...)
The parameter ext_yks
now also takes dict
s, which define the position
of the additional yks
.
Update: Batch.add_open_ends(..., replacements)
The new parameter replacements
is implemented. The method loops over the
whole pd.DataFrame and replaces all keys of the included dict
with the belonging value.
Update: Stack.add_stats(..., other_source)
Statistic views can now be added to delimited sets if other_source
is used.
In this case other_source
must be a single or numerical variable.
Update: DataSet.validate(..., spss_limits=False)
The new parameter spss_limits
is implemented. If spss_limits=True
, the
validate output dataframe is extended by 3 columns which show if the SPSS label
limitations are satisfied.
Bugfix: DataSet.convert()
A bug that prevented conversions from single
to numeric types has been fixed.
Bugfix: DataSet.add_meta()
A bug that prevented the creation of numerical arrays outside of to.array()
has been fixed. It is now possible to create array
metadata without providing
category references.
Bugfix: Stack.add_stats()
Checking the statistic views is skipped now if no single typed variables are included even if a checking cluster is provided.
Bugfix: Batch.copy()
Instead of using a deepcopy of the Batch
instance, a new instance is created
and filled with the attributes of the initial one. Then the copied instance can
be used as additional Batch
.
Bugfix: qp.core.builds.powerpoint
Access to bar-chart series and colour-filling is now working for
different Powerpoint versions. Also a bug is fixed which came up in
PowerPointpainter()
for variables which have fixed categories and whose
values are located in lib
.
sd (24/07/2017)¶
New: qp.set_option()
It is now possible to set library-wide settings registered in qp.OPTIONS
by providing the setting’s name (key) and the desired value. Currently supported
are:
OPTIONS = {
'new_rules': False,
'new_chains': False,
'short_item_texts': False
}
So for example, to work with the currently refactored Chain
interim class
we can use qp.set_options('new_chains', True)
.
New: qp.Batch()
This is a new object aimed at defining and structuring aggregation and build setups. Please see an extensive overview here.
New: Stack.aggregate()
/ add_nets()
/ add_stats()
/ add_tests()
/ …
Connected to the new Batch
class, some new Stack
methods to ease up
view creation have been added. You can find the docs here.
New: DataSet.populate()
Use this to create a qp.Stack
from Batch
definitions. This connects the
Batch
and Stack
objects; check out the Batch
and Analysis & aggregation docs.
New: DataSet.write_dimensions(path_mdd=None, path_ddf=None, text_key=None, mdm_lang='ENG', run=True, clean_up=True)
It is now possible to directly convert a DataSet
into a Dimensions .ddf/.mdd
file pair (given SPSS Data Collection Base Professional is installed on your
machine). By default, files will be saved to the same location in that the
DataSet
resides and keep its text_key
.
New: DataSet.repair()
This new method can be used to try to fix common DataSet
metadata problems
stemming from outdated versions, incorrect manual editing of the meta dictionary
or other inconsistencies. The method is checking and repairing following issues:
'name'
is present for all variable metadata'source'
and'subtype'
references for array variables- correct
'lib'
-based'values'
object for array variablestext key
-dependent'x edits'
/'y edits'
meta data['data file']['items']
set entries exist in'columns'
/'masks'
New: DataSet.subset(variables=None, from_set=None, inplace=False)
As a counterpart to filter()
, subset()
can be used to create a new
DataSet
that contains only a selection of variables. The new variables
collection can be provided either as a list of names or by naming an already
existing set containing the desired variables.
New: DataSet.variables_from_set(setname)
Get the list of variables belonging to the passed set indicated by
setname
.
New: DataSet.is_like_numeric(name)
A new method to test if all of a string
variable’s values can be converted
to a numerical (int
/ float
) type. Returns a boolean True
/ False
.
Update: DataSet.convert()
It is now possible to convert inplace from string
to int
/ float
if
the respective internal is_like_numeric()
check identifies numeric-like values.
Update: DataSet.from_components(..., reset=True)
, DataSet.read_quantipy(..., reset=True)
Loaded .json
metadata dictionaries will get cleaned now by default from any
user-defined, non-native objects inside the 'lib'
and 'sets'
collections. Set reset=False
to keep any extra entires (restoring the old
behaviour).
Update: DataSet.from_components(data_df, meta_dict=None, ...)
It is now possible to create a DataSet
instance by providing a pd.DataFrame
alone, without any accompanying meta data. While reading in the case data, the meta
component will be created by inferring the proper Quantipy
variable types
from the pandas
dtype
information.
Update: Quantity.swap(var, ..., update_axis_def=True)
It is now possible to swap()
the 'x'
variable of an array based Quantity
,
as long as the length oh the constructing 'items'
collection is identical.
In addition, the new parameter update_axis_def
is now by default enforcing
an update of the axis defintions (pd.DataFrame
column names, etc) while
previously the method was keeping the original index and column names. The old
behaviour can be restored by setting the parameter to False
.
Array example:
>>> link = stack[name_data]['no_filter']['q5']['@']
>>> q = qp.Quantity(link)
>>> q.summarize()
Array q5
Questions q5_1 q5_2 q5_3 q5_4 q5_5 q5_6
Question Values
q5 All 8255.000000 8255.000000 8255.000000 8255.000000 8255.000000 8255.000000
mean 26.410297 22.260569 25.181466 39.842883 24.399758 28.972017
stddev 40.415559 38.060583 40.018463 46.012205 40.537497 41.903322
min 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000
25% 3.000000 3.000000 3.000000 3.000000 1.000000 3.000000
median 5.000000 3.000000 3.000000 5.000000 3.000000 5.000000
75% 5.000000 5.000000 5.000000 98.000000 5.000000 97.000000
max 98.000000 98.000000 98.000000 98.000000 98.000000 98.000000
Updated axis definiton:
>>> q.swap('q7', update_axis_def=True)
>>> q.summarize()
Array q7
Questions q7_1 q7_2 q7_3 q7_4 q7_5 q7_6
Question Values
q7 All 1195.000000 1413.000000 3378.000000 35.000000 43.000000 36.000000
mean 5.782427 5.423213 5.795145 4.228571 4.558140 5.333333
stddev 2.277894 2.157226 2.366247 2.073442 2.322789 2.552310
min 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000
25% 4.000000 4.000000 4.000000 3.000000 3.000000 3.000000
median 6.000000 6.000000 6.000000 4.000000 4.000000 6.000000
75% 8.000000 7.000000 8.000000 6.000000 6.000000 7.750000
max 9.000000 9.000000 9.000000 8.000000 9.000000 9.000000
Original axis definiton:
>>> q = qp.Quantity(link)
>>> q.swap('q7', update_axis_def=False)
>>> q.summarize()
Array q5
Questions q5_1 q5_2 q5_3 q5_4 q5_5 q5_6
Question Values
q5 All 1195.000000 1413.000000 3378.000000 35.000000 43.000000 36.000000
mean 5.782427 5.423213 5.795145 4.228571 4.558140 5.333333
stddev 2.277894 2.157226 2.366247 2.073442 2.322789 2.552310
min 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000
25% 4.000000 4.000000 4.000000 3.000000 3.000000 3.000000
median 6.000000 6.000000 6.000000 4.000000 4.000000 6.000000
75% 8.000000 7.000000 8.000000 6.000000 6.000000 7.750000
max 9.000000 9.000000 9.000000 8.000000 9.000000 9.000000
Update: DataSet.merge_texts()
The method will now always overwrite existing text_key
meta, which makes it
possible to merge text
s from meta of the same text_key
as the master
DataSet
.
Bugfix: DataSet.band()
band(new_name=None)
’s automatic name generation was incorrectly creating
new variables with the name None_banded
. This is now fixed.
Bugfix: DataSet.copy()
The method will now check if the name of the copy already exists in the
DataSet
and drop the referenced variable if found to prevent
inconsistencies. Additionally, it is not longer possible to copy isolated
array
items:
>>> dataset.copy('q5_1')
NotImplementedError: Cannot make isolated copy of array item 'q5_1'. Please copy array variable 'q5' instead!
sd (08/06/2017)¶
New: DataSet.extend_valid_tks()
, DataSet.valid_tks
DataSet
has a new attribute valid_tks
that contains a list of all valid
textkeys. All methods that take a textkey as parameter are checked against that
list.
If a datafile contains a special/ unusual textkey (for example 'id-ID'
or
'zh-TW'
), the list can be extended with DataSet.extend_valid_tks()
.
This extension can also be used to create a textkey for special conditions,
for example to create texts only for powerpoint outputs:
>>> dataset.extend_valid_tks('pptx')
>>> dataset.force_texts('pptx', 'en-GB')
>>> dataset.set_variable_text('gender','Gender label for pptx', text_key='pptx')
New: Equal error messages
All methods that use the parameters name
/var
, text_key
or
axis_edit
/ axis
now have a decorator that checks the provided values.
The following shows a few examples for the new error messages:
name
& var
:
'name' argument for meta() must be in ['columns', 'masks'].
q1 is not in ['columns', 'masks'].
text_key
:
'en-gb' is not a valid text_key! Supported are: ['en-GB', 'da-DK', 'fi-FI', 'nb-NO', 'sv-SE', 'de-DE']
axis_edit
& axis
:
'xs' is not a valid axis! Supported are: ['x', 'y']
New: DataSet.repair_text_edits(text_key)
This new method can be used in trackers, that were drawn up in an older Quantipy
version. Text objects can be repaired if are not well prepared, for example if
it looks like this:
{'en-GB': 'some English text',
'sv_SE': 'some Swedish text',
'x edits': 'new text'}
DataSet.repair_text_edits()
loops over all text objects in the dataset and
matches the x edits
and y edits
texts to all included textkeys:
>>> dataset.repair_text_edits(['en-GB', 'sv-SE'])
{'en-GB': 'some English text',
'sv_SE': 'some Swedish text',
'x edits': {'en-GB': new text', 'sv-SE': 'new text'}}
Update: DataSet.meta()
/ .text()
/ .values()
/ .value_texts()
/ .items()
/ .item_texts()
All these methods now can take the parameters text_key
and axis_edit
.
The related text is taken from the meta information and shown in the output.
If a text key or axis edit is not included the text is returned as None.
Update: DataSet.compare(dataset, variables=None, strict=False, text_key=None)
The method is totally updated, works more precise and contains a few new
features. Generally variables included in dataset
are compared with
eponymous variables in the main DataSet
instance. You can specify witch
variables
should be compared, if question/ value texts should be compared
strict
or not and for which text_key
.
Update: DataSet.validate(verbose=True)
A few new features are tested now and the output has changed. Set verbose=True
to see the definitions of the different error columns:
name: column/mask name and meta[collection][var]['name'] are not identical
q_label: text object is badly formated or has empty text mapping
values: categorical var does not contain values, value text is badly
formated or has empty text mapping
textkeys: dataset.text_key is not included or existing tks are not
consistent (also for parents)
source: parents or items do not exist
codes: codes in .data are not included in .meta
Update: DataSet.sorting()
/ .slicing()
/ .hiding()
These methods will now also work on lists of variable names.
Update: DataSet.set_variable_text()
, Dataset.set_item_texts()
If these methods are applied to an array item, the new variable text is also included in the meta information of the parent array. The same works also the other way around, if an array text is set, then the array item texts are modified.
Update: DataSet.__init__(self, name, dimensions_comp=True)
A few new features are included to handle data coming from Crunch. While
initializing a new DataSet
instance dimensions compatibility can be set to
False. In the custom template use t.get_qp_dataset(name, dim_comp=False)
in the load cells.
Bugfix: DataSet.hmerge()
If right_on
and left_on
are used and right_on
is also included in
the main file, it is not overwritten any more.
sd (17/05/2017)¶
Update: DataSet.set_variable_text(..., axis_edit=None)
, DataSet.set_value_texts(..., axis_edit=False)
The new axis_edit
argument can be used with one of 'x'
, 'y'
or ['x', 'y']
to instruct a text metadata change that will only be visible in build exports.
Warning
In a future version set_col_text_edit()
and set_val_text_text()
will
be removed! The identical functionality is provided via this axis_edit
parameter.
Update: DataSet.replace_texts(..., text_key=None)
The method loops over all meta text objects and replaces unwanted strings.
It is now possible to perform the replacement only for specified text_key
s.
If text_key=None
the method replaces the strings for all text_key
s.
Update: DataSet.force_texts(copy_to=None, copy_from=None, update_existing=False)
The method is now only able to force texts for all meta text objects (for
single variables use the methods set_variable_text()
and
set_value_texts()
).
Bugfix: DataSet.copy()
Copied variables get the tag created
and can be listed with
t.list_variables(dataset, 'created')
.
Bugfix: DataSet.hmerge()
, DataSet.vmerge()
Array meta information in merged datafiles is now updated correctly.
sd (04/05/2017)¶
New: DataSet.var_exists()
Returns True if the input variable/ list of variables are included in the
DataSet
instance, otherwise False.
New: DataSet.remove_html()
, DataSet.replace_texts(replace)
The DataSet
method clean_texts()
has been removed and split into two
methods to make usage more clear: remove_html()
will strip all text
metadata objects from any html and formatting tags. replace_texts()
will
use a dict
mapping of old to new str
terms to change the matching
text
throughout the DataSet
metadata.
New: DataSet.item_no(name)
This method will return the positional index number of an array item, e.g.:
>>> dataset.item_no('Q4A[{q4a_1}].Q4A_grid')
1
New: QuantipyViews
: counts_cumsum
, c%_cumsum
These two new views contain frequencies with cumulative sums which are computed over the x-axis.
Update: DataSet.text(name, shorten=True)
The new parameter shorten
is now controlling if the variable text
metadata
of array masks will be reported in short format, i.e. without the corresponding
mask label text. This is now also the default behaviour.
Update: DataSet.to_array()
Created mask meta information now also contains keys parent
and subtype
.
Variable names are compatible with crunch and dimensions meta:
Example in Dimensions modus:
>>> dataset.to_array('Q11', ['Q1', 'Q2', 'Q3', 'Q4', 'Q5'], 'label')
The new grid is named 'Q11.Q11_grid'
and the source/column variables are
'Q11[{Q1}].-Q11_grid'
- 'Q11[{Q5}].-Q11_grid'
.
Bugfix: DataSet.derotate()
Meta is now Crunch and Dimensions compatible. Also mask meta information are updated.
sd (24/04/2017)¶
Update: DataSet.hiding(..., hide_values=True)
The new parameter hide_values
is only necessary if the input variable is a
mask. If False
, mask items are hidden, if True
mask values are hidden
for all mask items and for array summary sheets.
Bugfix: DataSet.set_col_text_edit(name)
If the input variable is an array item, the new column text is also added to
meta['mask'][name]['items]
.
Bugfix: DataSet.drop(name, ignore_items=False)
If a mask is dropped, but the items are kept, all items are handled now as
individual variables and their meta information is not stored in meta['lib']
anymore.
sd (06/04/2017)¶
Only small adjustments.
sd (29/03/2017)¶
New: DataSet.codes_in_data(name)
This method returns a list of codes that exist in the data of a variable. This information can be used for more complex recodes, for example copying a variable, but keeping only all categories with more than 50 ratings, e.g.:
>>> valid_code = dataset.codes_in_data('varname')
>>> keep_code = [x for x in valid_code if dataset['varname'].value_counts()[x] > 49]
>>> dataset.copy('varname', 'rc', copy_only=keep_code)
Update: DataSet.copy(..., copy_not=None)
The new parameter copy_not
takes a list of codes that should be ignored
for the copied version of the provided variable. The metadata of the copy will
be reduced as well.
Update: DataSet.code_count()
This method is now alligned with any()
and all()
in that it can be used
on 'array'
variables as well. In such a case, the resulting pandas.Series
is reporting the number of answer codes found across all items per case data
row, i.e.:
>>> code_count = dataset.code_count('Q4A.Q4A_grid', count_only=[3, 4])
>>> check = pd.concat([dataset['Q4A.Q4A_grid'], code_count], axis=1)
>>> check.head(10)
Q4A[{q4a_1}].Q4A_grid Q4A[{q4a_2}].Q4A_grid Q4A[{q4a_3}].Q4A_grid 0
0 3.0 3.0 NaN 2
1 NaN NaN NaN 0
2 3.0 3.0 4.0 3
3 5.0 4.0 2.0 1
4 4.0 4.0 4.0 3
5 4.0 5.0 4.0 2
6 3.0 3.0 3.0 3
7 4.0 4.0 4.0 3
8 6.0 6.0 6.0 0
9 4.0 5.0 5.0 1
sd (20/03/2017)¶
New: qp.DataSet(dimensions_comp=True)
The DataSet
class can now be explicitly run in a Dimensions compatibility
mode to control the naming conventions of array
variables (“grids”). This
is also the default behaviour for now. This comes with a few changes related to
meta creation and variable access using DataSet
methods. Please see a brief
case study on this topic here.
New: enriched items
/ masks
meta data
masks
will now also store the subtype
(single
, delimited set
, etc.)
while items
elements will now contain a reference to the defining masks
entrie(s) in a new parent
object.
Update: DataSet.weight(..., subset=None)
Filters the dataset by giving a Quantipy complex logic expression and weights only the remaining subset.
Update: Defining categorical values
meta and array
items
Both values
and items
can now be created in three different ways when
working with the DataSet
methods add_meta()
, extend_values()
and
derive()
: (1) Tuples that map element code to label, (2) only labels or (3)
only element codes. Please see quick guide on that here
sd (07/03/2017)¶
Update: DataSet.code_count(..., count_not=None)
The new parameter count_not
can be used to restrict the set of codes feeding
into the resulting pd.Series
by exclusion (while count_only
restricts
by inclusion).
Update: DataSet.copy(..., copy_only=None)
The new parameter copy_only
takes a list of codes that should be included
for the copied version of the provided variable, all others will be ignored
and the metadata of the copy will be reduced as well.
Bugfix: DataSet.band()
There was a bug that was causing the method to crash for negative values. It is
now possible to create negative single value bands, while negative ranges
(lower and/or upper bound < 0) will raise a ValueError
.
sd (24/02/2017)¶
- Some minor bugfixes and updates. Please use latest version.
sd (16/02/2017)¶
New: DataSet.derotate(levels, mapper, other=None, unique_key='identity', dropna=True)
Create a derotated (“levelled”, responses-to-cases) DataSet
instance by
defining level variables, looped variables and other (simple) variables that
should be added.
View more information on the topic here.
New: DataSet.to_array(name, variables, label)
Combine column
variables with identical values
objects to an array
incl. all required meta['masks']
information.
Update: DataSet.interlock(..., variables)
It is now possible to add dict
s to variables
. In these dict
s a
derive()
-like mapper can be included which will then create a temporary
variable for the interlocked result. Example:
>>> variables = ['gender',
... {'agegrp': [(1, '18-34', {'age': frange('18-34')}),
... (2, '35-54', {'age': frange('35-54')}),
... (3, '55+', {'age': is_ge(55)})]},
... 'region']
>>> dataset.interlock('new_var', 'label', variables)
sd (04/01/2017)¶
New: DataSet.flatten(name, codes, new_name=None, text_key=None)
Creates a new delimited set
variable that groups grid item
answers to
categories. The items
become values
of the new variable. If an
item
contains one of the codes
it will be counted towards the categorical
case data of the new variable.
New: DataSet.uncode(target, mapper, default=None, intersect=None, inplace=True)
Remove codes from the target
variable’s data component if a logical
condition is satisfied.
New: DataSet.text(var, text_key=None)
Returns the question text label (per text_key
) of a variable.
New: DataSet.unroll(varlist, keep=None, both=None)
Replaces masks
names inside varlist
with their items
. Optionally,
individual masks
can be excluded or kept inside the list.
New: DataSet.from_stack(stack, datakey=None)
Create a quantipy.DataSet
from the meta
, data
, data_key
and
filter
definition of a quantipy.Stack
instance.
sd (8/12/2016)¶
New:
DataSet.from_excel(path_xlsx, merge=True, unique_key='identity')
Returns a new DataSet
instance with data
from excel
. The meta
for all variables contains type='int'
.
Example: new_ds = dataset.from_excel(path, True, 'identity')
The function is able to modify dataset
inplace by merging new_ds
on
identity
.
Update:
DataSet.copy(..., slicer=None)
It is now possible to filter the data that statisfies the logical condition
provided in the slicer
.
Example:
>>> dataset.copy('q1', 'rec', True, {'q1': not_any([99])})
sd (23/11/2016)¶
Update:
DataSet.rename(name, new_name=None, array_item=None)
The function is able to rename columns
, masks
or mask items
.
maks items
are changed by position.
Update:
DataSet.categorize(..., categorized_name=None)
Provide a custom name string for categorized_name
will change the default
name of the categorized variable from OLD_NAME#
to the passed string.
sd (16/11/2016)¶
New:
DataSet.check_dupe(name='identity')
Returns a list with duplicated values for the variable provided via name
.
Identifies for example duplicated identities.
New:
DataSet.start_meta(text_key=None)
Creates an empty QP meta data document blueprint to add variable definitions to.
Update:
DataSet.create_set(setname='new_set', based_on='data file', included=None,
... excluded=None, strings='keep', arrays='both', replace=None,
... overwrite=False)
Add a new set
to the meta['sets']
object. Variables from an existing
set
(based_on
) can be included
to new_set
or varibles can be
excluded
from based_on
with customized lists of variables.
Control string
variables and masks
with the kwargs
strings
and
arrays
. replace
single variables in new_set
with a dict
.
Update:
DataSet.from_components(..., text_key=None)
Will now accept a text_key
in the method call. If querying a text_key
from the meta component fails, the method will no longer crash, but raise a
warning
and set the text_key
to None
.
Update:
DataSet.as_float()
DataSet.as_int()
DataSet.as_single()
DataSet.as_delimited_set()
DataSet.as_string()
DataSet.band_numerical()
DataSet.derive_categorical()
DataSet.set_mask_text()
DataSet.set_column_text()
These methods will now print a UserWarning
to prepare for the soon to
come removal of them.
Bugfix:
DataSet.__setitem__()
Trying to set np.NaN
was failing the test against meta data for categorical
variables and was raising a ValueError
then. This is fixed now.
sd (11/11/2016)¶
New:
DataSet.columns
DataSet.masks
DataSet.sets
DataSet.singles
DataSet.delimited_sets
DataSet.ints
DataSet.floats
DataSet.dates
DataSet.strings
New DataSet
instance attributes to quickly return the list of columns
,
masks
and sets
objects from the meta or query the variables by
type
. Use this to check for variables, iteration, inspection, ect.
New:
DataSet.categorize(name)
Create a categorized version of int/string/date
variables. New variables
will be named as per OLD_NAME#
New:
DataSet.convert(name, to)
Wraps the individual as_TYPE()
conversion methods. to
must be one of
'int', 'float', 'string', 'single', 'delimited set'
.
New:
DataSet.as_string(name)
Only for completeness: Use DataSet.convert(name, to='string')
instead.
Converts int/float/single/date
typed variables into a string
and
removes all categorical metadata.
Update:
DataSet.add_meta()
Can now add date
and text
type meta data.
Bugfix:
DataSet.vmerge()
If masks
in the right dataset
, that also exist in the left dataset
,
have new items
or values
, they are added to meta['masks']
,
meta['lib']
and meta['sets']
.
sd (09/11/2016)¶
New:
DataSet.as_float(name)
Converts int/single
typed variables into a float
and removes
all categorical metadata.
New:
DataSet.as_int(name)
Converts single
typed variables into a int
and removes
all categorical metadata.
New:
DataSet.as_single(name)
Converts int
typed variables into a single
and adds numeric values as
categorical metadata.
New:
DataSet.create_set(name, variables, blacklist=None)
Adds a new set
to meta['sets']
object. Create easily sets
from
other sets
while using customised blacklist
.
New:
DataSet.drop(name, ignore_items=False)
Removes all metadata and data referenced to the variable. When passing an
array mask
, ignore_items
can be ste to True
to keep the item
columns
incl. their metadata.
New:
DataSet.compare(dataset=None, variables=None)
Compare the metadata definition between the current and another dataset
,
optionally restricting to a pair of variables.
Update:
DataSet.__setitem__()
[..]
-Indexer now checks scalars against categorical meta.


--- layout: docs_default title: Unit Neurons Documentation - Kohonen's Self Organizing Map ---
FloatMappingNeuron(_prevs, _num_prev, _query_manager)
_prevs
(FloatUnitNeuron**
)
FloatUnitNeuron
and its subclass instances
previous
neurons that the current neuron derives
state
data from
FloatUnitNeuron
, include (FloatUnitNeuron**)
in front of the variable
_num_prevs
int
) in the _prevs
array
_query_manager
(FeedbackQueryManager*
)
FeedbackQueryManager
instance
FloatMappingNeuron(_prevs, _num_prev, _query_manager, _max)
_prevs
(FloatUnitNeuron**
)
FloatUnitNeuron
and its subclass instances
previous
neurons that the current neuron derives
state
data from
FloatUnitNeuron
, include (FloatUnitNeuron**)
in front of the variable
_num_prevs
int
) in the _prevs
array
_query_manager
FeedbackQueryManager
instance
_max
lr
(floating point value)
0.7f
void assign_neighbors(FloatMappingNeuron** _neighbors, int _num_neighbors)
_neighbors
FloatMappingNeuron
_num_neighbors
_neighbors
void feedforward()
void feedback(float* fb_input)
feedforward()
fb_input
is a 2-D array that consists of
{CURRENT_NUMBER_OF_NEIGHBORS, NUMBER_OF_NEIGHBORS_TO_UPDATE}
float* see_memory()
For more details on private variables, methods, and other functionalities performed within the definition of the class, refer to the hpp file and the cpp file .
Subclass of GlobalOperator
that starts the
Kohonen's self organizing map
training process of the neural network
FloatKohonenSOM(_maps, int _num_maps, int _neighbor_range)
_maps
(FloatMappingNeuron**
)
FloatMappingNeuron
used as the output neurons
_num_maps
int
) in _maps
_neighbor_range
For more details on private variables, methods, and other functionalities performed within the definition of the class, refer to the hpp file and the cpp file .


BUYCollectionSort Constants Reference
| Declared in | BUYClient.h |
|---|
BUYCollectionSort
The sort order for products in a collection
Definition
typedef NS_ENUM(NSUInteger, BUYCollectionSort ) {
BUYCollectionSortCollectionDefault,
BUYCollectionSortBestSelling,
BUYCollectionSortTitleAscending,
BUYCollectionSortTitleDescending,
BUYCollectionSortPriceAscending,
BUYCollectionSortPriceDescending,
BUYCollectionSortCreatedAscending,
BUYCollectionSortCreatedDescending,
};
Constants
BUYCollectionSortCollectionDefault
-
Sort products by best selling using the order set in the shop’s admin
Declared In
BUYClient.h
. BUYCollectionSortBestSelling
-
Sort products by best selling
Declared In
BUYClient.h
. BUYCollectionSortTitleAscending
-
Sort products by title, ascending
Declared In
BUYClient.h
. BUYCollectionSortTitleDescending
-
Sort products by title, descending
Declared In
BUYClient.h
. BUYCollectionSortPriceAscending
-
Sort products by price (first variant), ascending
Declared In
BUYClient.h
. BUYCollectionSortPriceDescending
-
Sort products by price (first variant), descending
Declared In
BUYClient.h
. BUYCollectionSortCreatedAscending
-
Sort products by creation date, ascending
Declared In
BUYClient.h
. BUYCollectionSortCreatedDescending
-
Sort products by creation date, descending
Declared In
BUYClient.h
.
Declared In
BUYClient.h


Operation Santa begins, find out how you can help
by Natalie Dreier, Cox Media Group National Content DeskIt's been more than 100 years since Operation Santa began, and the program that was designed to bring a smile to children around the country is still going strong.
When the program started in 1912 by then-Postmaster General Frank Hitchcock, it didn't have a name. But Hitchcock allowed local postmasters, employees, and everyday people to pick a letter written to Santa and respond.
In the 1940s, Santa received so much mail, charitable organizations and corporations started to help write back to children and families and provided small gifts.
Operation Santa is once again online at USPSOperationSanta.com.
On the website, you can read through the letters that have been sent to Santa's mail room and answer one or more.
Some of the letters were written by children who are asking for video games, Legos and other toys.
But some of the letters, written by adults, talk about the struggles they are experiencing, but who still want to provide a Merry Christmas for their children.
If you want to help, you begin by registering online and go through an identification process. Then you go to a participating post office, with letter and gift in hand, to ship it to the recipient. A code included on the letter matches the name and address of the child or family that had submitted the request to Santa.
© 2019 Cox Media Group.


--- layout: post date: 2005-12-09 time: "09:00:00" authors: ["Greg Wilson"] title: "American Scientist article on Software Carpentry" tags: ["Communications"] ---
The Jan/Feb 2006 issue of American Scientist, the magazine of Sigma Xi, contains an article on Software Carpentry.


Shelter Care Encounter Form Portals
Sign Out
Client Name
Address
Program
Issue Needing Attention
Smoking in Unit
Housekeeping Issues
Guest Issues
Neighbor Complaint
Other Issue
Response
Addressed through Home Visit
Inspection Requested
Issue Notice
Comments


9 references to CommandOrigin
Microsoft.PowerShell.Commands.Utility (1)
commands\utility\NewAliasCommand.cs (1)
41
SessionState.ThrowIfNotVisible(this.
CommandOrigin
, existingAlias);
System.Management.Automation (8)
engine\InvocationInfo.cs (1)
30
CommandOrigin = command.
CommandOrigin
;
engine\MshCmdlet.cs (1)
318
commandOrigin = _cmdlet.
CommandOrigin
;
engine\remoting\commands\RemoveJob.cs (1)
756
CommandDiscovery.AutoloadModulesWithJobSourceAdapters(this.Context, this.
CommandOrigin
);
engine\remoting\commands\StartJob.cs (1)
625
CommandDiscovery.AutoloadModulesWithJobSourceAdapters(this.Context, this.
CommandOrigin
);
engine\ScriptCommandProcessor.cs (1)
482
this._dontUseScopeCommandOrigin ? CommandOrigin.Internal : this.Command.
CommandOrigin
;
namespaces\CoreCommandContext.cs (3)
125
Origin = command.
CommandOrigin
;
179
Origin = command.
CommandOrigin
;
227
Origin = command.
CommandOrigin
;


|
RayTracer
|
Transformation objects represent angle-preserving transformations. More...
#include <Transformation.h>
Public Member Functions | |
| Transformation (Matrix3D A, Vector3D v, double s) | |
| Construct Transformation from Orthogonal Matrix A, translation and scaling-factor. More... | |
| Transformation (Vector3D v, double psi, double theta, double phi, double s) | |
| Construct the Transformation from euler angles, translation and scaling-factor. More... | |
| void | compose_back (const Transformation &b) |
| Compose this transformation with b. More... | |
| Vector3D | transform (const Vector3D &v) const |
| Apply this transformation to v in 3D space. More... | |
| Ray | transform (const Ray &ray) const |
| Ray | inverse_transform (const Ray &ray) const |
| Vector3D | inverse_transform (const Vector3D &v) const |
| The inverse to Transformation::transform. More... | |
| Vector3D | rotate (const Vector3D &v) const |
| Vector3D | inverse_rotate (const Vector3D &v) const |
Private Attributes | |
| Matrix3D | A |
| Matrix3D | A_transpose |
| Vector3D | translation |
| double | scale |
Transformation objects represent angle-preserving transformations.
These transformations are modelled as the composition of a translation, a rotation (i.e. orthogonal linear transform) and a scaling step.
Construct Transformation from Orthogonal Matrix A, translation and scaling-factor.
| A | Orthogonal Matrix describing rotation |
| v | Translation |
| s | Scaling Factor |
| linalg::Transformation::Transformation | ( | Vector3D | v, |
| double | psi, | ||
| double | theta, | ||
| double | phi, | ||
| double | s | ||
| ) |
Construct the Transformation from euler angles, translation and scaling-factor.
| v | The translation |
| psi | Euler angle 1 |
| theta | Euler angle 2 |
| phi | Euler angle 3 |
| s | Scaling Factor |
| void linalg::Transformation::compose_back | ( | const Transformation & | b | ) |
Compose this transformation with b.
From now on b will be applied first, the the original transformation.
| b | Other transformation |
The inverse to Transformation::transform.
| v | The vector that is supposed to be transformed |
Apply this transformation to v in 3D space.
| v | The vector that is supposed to be transformed |
|
private |
|
private |
|
private |
|
private |


Core object representing the game itself. More...
Public Member Functions | |
| GameController (MachineType machineType, ILogger logger) | |
| Creates a new GameController object with the given machine type and logging infrastructure. | |
| virtual void | Reset () |
| Reset the game state to normal (like a slam tilt) | |
| Player | create_player (string name) |
| Creates a new player with a given name. | |
| Player | add_player () |
| Adds a new player to 'Players' and auto-assigns a name. | |
| Player | current_player () |
| Returns the current 'Player' object according to the current_player_index value. | |
| double | get_ball_time () |
| The ball time for the current player. | |
| double | get_game_time (int player) |
| The game time for the given player index. | |
| void | save_ball_start_time () |
| Save the ball start time into local memory. | |
| void | start_ball () |
| Called by the implementor to notify the game that the first ball should be started. | |
| virtual void | ball_starting () |
| Called by the game framework when a new ball is starting. | |
| virtual void | shoot_again () |
| Called by the game framework when a new ball is starting which was the result of a stored extra ball. The default implementation calls ball_starting() which is not called by the framework in this case. | |
| virtual void | ball_ended () |
| Called by the game framework when the current ball has ended. | |
| void | end_ball () |
| Called by the implementor to notify the game that the current ball has ended. | |
| void | game_started () |
| Called by the GameController when a new game is starting. | |
| virtual void | start_game () |
| Called by the implementor to notify the game that the game has started. | |
| virtual void | game_ended () |
| Called by the GameController when the current game has ended. | |
| void | end_game () |
| Called by the implementor to notify the game that the game as ended. | |
| void | LoadConfig (string PathToFile) |
| Create a new machine configuration representation in memory from a file on disk. | |
| void | process_event (Event evt) |
| Process the retrieved event from the PROC interface board (switch/dmd events) | |
| void | update_lamps () |
| void | end_run_loop () |
| Set the exit condition for the run loop causing the game to terminate. | |
| Event[] | get_events () |
| Retrieve all events from the PROC interface board. | |
| void | tick_virtual_drivers () |
| Propagate Tick events to all lamps and coils. | |
| void | tick () |
| void | run_loop () |
| Main run loop of the program. Performs the following logic until the loop ends: | |
Public Attributes | |
| int | ball = 0 |
| The number of the current ball. A value of 1 represents the first ball; 0 indicates game over. | |
Protected Member Functions | |
| void | Log (string text) |
Protected Attributes | |
| MachineType | _machineType |
| Machine type used to configure the proc device. | |
| ProcDevice | _proc |
| A pinproc class instance, created in the constructor with the Machine_Type attribute. | |
| ModeQueue | _modes |
| TODO: Implement mode queue logic. | |
| AttrCollection< ushort, string, Driver > | _coils |
| TODO: implement coil driver object list. | |
| AttrCollection< ushort, string, Driver > | _lamps |
| TODO: implement lamp driver object list. | |
| AttrCollection< ushort, string, Driver > | _gi |
| List of GI drivers. | |
| AttrCollection< ushort, string, Switch > | _switches |
| TODO: implement switch object lists. | |
| List< Player > | _players |
| A collection of player objects. | |
| List< Player > | _old_players |
| A collection of old player objects if reset is called. | |
| int | _current_player_index = 0 |
| The index in _players of the current player TODO: implement this logic. | |
| double | _bootTime = 0 |
| The date/time when the framework was started (machine powered up) | |
| MachineConfiguration | _config |
| The configuration object loaded by load_config() TODO: implement config handling. | |
| int | _balls_per_game = 3 |
| The number of balls per game. | |
| object | _game_data |
| Contains information specific to the particular location installation (high scores, audits, etc). | |
| object | _user_settings |
| Contains local game information such as volume. | |
| int | _num_balls_total = 5 |
| The total number of balls in the machine. | |
| bool | _flippers_enabled = false |
| Are the flippers and bumpers currently enabled? | |
| bool | _done = false |
| Run loop exit condition. This continues until true. | |
| double | _ball_end_time |
| The ending time of the current ball. | |
| double | _ball_start_time |
| The starting time of the current ball. | |
Properties | |
| ILogger | Logger [get, set] |
| Public logging interface class. Make sure all games have a class that implements this interface. | |
| MachineConfiguration | Config [get] |
| Current machine configuration representation. | |
| ProcDevice | PROC [get] |
| PROC device driver wrapper. | |
| bool | FlippersEnabled [get, set] |
| Enables/disables flippers and other high-power coils (bumpers) | |
| AttrCollection< ushort, string, Driver > | Coils [get, set] |
| All coils/solenoids within the game. | |
| AttrCollection< ushort, string, Driver > | Lamps [get, set] |
| All lamps within the game. | |
| AttrCollection< ushort, string, Driver > | GI [get, set] |
| All GI drivers within the game. | |
| AttrCollection< ushort, string, Switch > | Switches [get, set] |
| All switches and optos within the game. | |
| ModeQueue | Modes [get, set] |
| The current list of modes that are active in the game. |
Core object representing the game itself.
Usually a game developer will create a new game by subclassing this class. Consider subclassing 'BasicGame' instead, as it makes use of several helpful modes and controllers.
| NetProcGame.game.GameController.GameController | ( | MachineType | machineType, |
| ILogger | logger | ||
| ) |
Creates a new GameController object with the given machine type and logging infrastructure.
| machineType | Machine type to use (WPC, STERN, PDB etc) |
| logger | The logger interface to use |
Adds a new player to 'Players' and auto-assigns a name.
| virtual void NetProcGame.game.GameController.ball_ended | ( | ) | [virtual] |
Called by the game framework when the current ball has ended.
| virtual void NetProcGame.game.GameController.ball_starting | ( | ) | [virtual] |
Called by the game framework when a new ball is starting.
| Player NetProcGame.game.GameController.create_player | ( | string | name | ) |
Creates a new player with a given name.
| name | The name for the player to use, usually auto generated |
Returns the current 'Player' object according to the current_player_index value.
Called by the implementor to notify the game that the current ball has ended.
Called by the implementor to notify the game that the game as ended.
Set the exit condition for the run loop causing the game to terminate.
| virtual void NetProcGame.game.GameController.game_ended | ( | ) | [virtual] |
Called by the GameController when the current game has ended.
Called by the GameController when a new game is starting.
The ball time for the current player.
Retrieve all events from the PROC interface board.
| double NetProcGame.game.GameController.get_game_time | ( | int | player | ) |
The game time for the given player index.
| player | The player index to calculate the game time for |
| void NetProcGame.game.GameController.LoadConfig | ( | string | PathToFile | ) |
Create a new machine configuration representation in memory from a file on disk.
| PathToFile | The path to the configuration XML file |
TODO: THIS SHOULD RETURN A LIST OF STATES
| void NetProcGame.game.GameController.process_event | ( | Event | evt | ) |
Process the retrieved event from the PROC interface board (switch/dmd events)
| evt | The event to process |
| virtual void NetProcGame.game.GameController.Reset | ( | ) | [virtual] |
Reset the game state to normal (like a slam tilt)
Main run loop of the program. Performs the following logic until the loop ends:
Save the ball start time into local memory.
| virtual void NetProcGame.game.GameController.shoot_again | ( | ) | [virtual] |
Called by the game framework when a new ball is starting which was the result of a stored extra ball. The default implementation calls ball_starting() which is not called by the framework in this case.
Called by the implementor to notify the game that the first ball should be started.
| virtual void NetProcGame.game.GameController.start_game | ( | ) | [virtual] |
Called by the implementor to notify the game that the game has started.
Propagate Tick events to all lamps and coils.
double NetProcGame.game.GameController._ball_end_time [protected] |
The ending time of the current ball.
double NetProcGame.game.GameController._ball_start_time [protected] |
The starting time of the current ball.
int NetProcGame.game.GameController._balls_per_game = 3 [protected] |
The number of balls per game.
double NetProcGame.game.GameController._bootTime = 0 [protected] |
The date/time when the framework was started (machine powered up)
AttrCollection<ushort, string, Driver> NetProcGame.game.GameController._coils [protected] |
TODO: implement coil driver object list.
The configuration object loaded by load_config() TODO: implement config handling.
int NetProcGame.game.GameController._current_player_index = 0 [protected] |
The index in _players of the current player TODO: implement this logic.
bool NetProcGame.game.GameController._done = false [protected] |
Run loop exit condition. This continues until true.
bool NetProcGame.game.GameController._flippers_enabled = false [protected] |
Are the flippers and bumpers currently enabled?
object NetProcGame.game.GameController._game_data [protected] |
Contains information specific to the particular location installation (high scores, audits, etc).
AttrCollection<ushort, string, Driver> NetProcGame.game.GameController._gi [protected] |
List of GI drivers.
AttrCollection<ushort, string, Driver> NetProcGame.game.GameController._lamps [protected] |
TODO: implement lamp driver object list.
MachineType NetProcGame.game.GameController._machineType [protected] |
Machine type used to configure the proc device.
ModeQueue NetProcGame.game.GameController._modes [protected] |
TODO: Implement mode queue logic.
int NetProcGame.game.GameController._num_balls_total = 5 [protected] |
The total number of balls in the machine.
List<Player> NetProcGame.game.GameController._old_players [protected] |
A collection of old player objects if reset is called.
List<Player> NetProcGame.game.GameController._players [protected] |
A collection of player objects.
ProcDevice NetProcGame.game.GameController._proc [protected] |
A pinproc class instance, created in the constructor with the Machine_Type attribute.
AttrCollection<ushort, string, Switch> NetProcGame.game.GameController._switches [protected] |
TODO: implement switch object lists.
object NetProcGame.game.GameController._user_settings [protected] |
Contains local game information such as volume.
The number of the current ball. A value of 1 represents the first ball; 0 indicates game over.
AttrCollection<ushort, string, Driver> NetProcGame.game.GameController.Coils [get, set] |
All coils/solenoids within the game.
Current machine configuration representation.
bool NetProcGame.game.GameController.FlippersEnabled [get, set] |
Enables/disables flippers and other high-power coils (bumpers)
AttrCollection<ushort, string, Driver> NetProcGame.game.GameController.GI [get, set] |
All GI drivers within the game.
AttrCollection<ushort, string, Driver> NetProcGame.game.GameController.Lamps [get, set] |
All lamps within the game.
ILogger NetProcGame.game.GameController.Logger [get, set] |
Public logging interface class. Make sure all games have a class that implements this interface.
ModeQueue NetProcGame.game.GameController.Modes [get, set] |
The current list of modes that are active in the game.
PROC device driver wrapper.
AttrCollection<ushort, string, Switch> NetProcGame.game.GameController.Switches [get, set] |
All switches and optos within the game.


|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object java.rmi.server.RMIClassLoaderSpi
public abstract class RMIClassLoaderSpi
RMIClassLoaderSpi
is the service provider interface for
RMIClassLoader
.
In particular, an RMIClassLoaderSpi
instance provides an
implementation of the following static methods of
RMIClassLoader
:
RMIClassLoader.loadClass(URL,String)
RMIClassLoader.loadClass(String,String)
RMIClassLoader.loadClass(String,String,ClassLoader)
RMIClassLoader.loadProxyClass(String,String[],ClassLoader)
RMIClassLoader.getClassLoader(String)
RMIClassLoader.getClassAnnotation(Class)
RMIClassLoader
for a description
of how a provider instance is chosen.
RMIClassLoader
| Constructor Summary | |
|---|---|
RMIClassLoaderSpi()
|
| Method Summary | |
|---|---|
abstract String |
getClassAnnotation(Class<?> cl)
Provides the implementation for RMIClassLoader.getClassAnnotation(Class) . |
abstract ClassLoader |
getClassLoader(String codebase)
Provides the implementation for RMIClassLoader.getClassLoader(String) . |
abstract Class<?> |
loadClass(String codebase,
String name,
ClassLoader defaultLoader)
Provides the implementation for RMIClassLoader.loadClass(URL,String) ,
RMIClassLoader.loadClass(String,String) , and
RMIClassLoader.loadClass(String,String,ClassLoader) . |
abstract Class<?> |
loadProxyClass(String codebase,
String[] interfaces,
ClassLoader defaultLoader)
Provides the implementation for RMIClassLoader.loadProxyClass(String,String[],ClassLoader) . |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public RMIClassLoaderSpi()
| Method Detail |
|---|
public abstract Class<?> loadClass(String codebase, String name, ClassLoader defaultLoader) throws MalformedURLException, ClassNotFoundException
RMIClassLoader.loadClass(URL,String)
,
RMIClassLoader.loadClass(String,String)
, and
RMIClassLoader.loadClass(String,String,ClassLoader)
.
Loads a class from a codebase URL path, optionally using the
supplied loader.
Typically, a provider implementation will attempt to
resolve the named class using the given defaultLoader
,
if specified, before attempting to resolve the class from the
codebase URL path.
An implementation of this method must either return a class with the given name or throw an exception.
codebase
- the list of URLs (separated by spaces) to load
the class from, or null
name
- the name of the class to loaddefaultLoader
- additional contextual class loader
to use, or null
Class
object representing the loaded class
MalformedURLException
- if codebase
is
non-null
and contains an invalid URL, or
if codebase
is null
and a provider-specific
URL used to load classes is invalid
ClassNotFoundException
- if a definition for the class
could not be found at the specified locationpublic abstract Class<?> loadProxyClass(String codebase, String[] interfaces, ClassLoader defaultLoader) throws MalformedURLException, ClassNotFoundException
RMIClassLoader.loadProxyClass(String,String[],ClassLoader)
.
Loads a dynamic proxy class (see Proxy
that implements a set of interfaces with the given names
from a codebase URL path, optionally using the supplied loader.
An implementation of this method must either return a proxy class that implements the named interfaces or throw an exception.
codebase
- the list of URLs (space-separated) to load
classes from, or null
interfaces
- the names of the interfaces for the proxy class
to implementdefaultLoader
- additional contextual class loader
to use, or null
MalformedURLException
- if codebase
is
non-null
and contains an invalid URL, or
if codebase
is null
and a provider-specific
URL used to load classes is invalid
ClassNotFoundException
- if a definition for one of
the named interfaces could not be found at the specified location,
or if creation of the dynamic proxy class failed (such as if
Proxy.getProxyClass(ClassLoader,Class[])
would throw an IllegalArgumentException
for the given
interface list)public abstract ClassLoader getClassLoader(String codebase) throws MalformedURLException
RMIClassLoader.getClassLoader(String)
.
Returns a class loader that loads classes from the given codebase
URL path.
If there is a security manger, its checkPermission
method will be invoked with a
RuntimePermission("getClassLoader")
permission;
this could result in a SecurityException
.
The implementation of this method may also perform further security
checks to verify that the calling context has permission to connect
to all of the URLs in the codebase URL path.
codebase
- the list of URLs (space-separated) from which
the returned class loader will load classes from, or null
MalformedURLException
- if codebase
is
non-null
and contains an invalid URL, or
if codebase
is null
and a provider-specific
URL used to identify the class loader is invalid
SecurityException
- if there is a security manager and the
invocation of its checkPermission
method fails, or
if the caller does not have permission to connect to all of the
URLs in the codebase URL pathpublic abstract String getClassAnnotation(Class<?> cl)
RMIClassLoader.getClassAnnotation(Class)
.
Returns the annotation string (representing a location for
the class definition) that RMI will use to annotate the class
descriptor when marshalling objects of the given class.
cl
- the class to obtain the annotation for
null
NullPointerException
- if cl
is null
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Copyright © 2004, 2010 Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.


This release fixes a critical issue with Picturefill's currentSrc
support test. This issue caused errors in both the Spartan and WebKit nightlies.
Changes from Picturefill 2.3 Beta
sizes
values now fall back to 100vw
default (f379528)Along with assorted bugfixes and performance improvements, the following major issues have been addressed with this release:
Added support detection for the following image types: jpxr, jpg2000, and apng.
Image format support can now be handled using extensions. SVG and WebP remain a part of the Picturefill core, so as not to break existing implementations.
Support for intrinsic image dimensions
Picturefill now matches native behavior in terms of an image’s inherent size: when served at “2x,” the image is displayed at half of its source’s inherent size. Note that this can and must be overrideable via CSS.
Picturefill is now a named AMD module, and uses AMD/CommonJS module factory also in native supporting browsers.
Picturefill has a team now
Everyone join me in welcoming the team responsible for the lion’s share of work that went into this release, and many more to come.
Did someone just whisper “Picturefill 3?”
I thought I just heard someone whisper “Picturefill 3.” Weird.
Assorted bugfixes, improvements to compatibility in AMD environments, minor improvements to performance and spec compliance.
source
parsing algorithm outlined in the spec (find all img
, check for parent picture
elements, process any/all source
elements until finding the img
that invoked it all)srcset
syntax without an explicit sizes
attribute, per the spec


{% load static %} {% block content %}
Important: The lake story map requires the use of two fingers to pan and zoom around the lake area on a mobile device.
The map has restricted bounds based on each lakes' boundary. The map also has restricted minimum zoom (how far you can zoom out).
To view the available tools in a lake story view, click the tools menu icon in the top right of the map.
In the tools menu under the time slider, some lakes have hyperlinked years that will send you to that specific historical imagery collection via the TNRIS DataHub. To view an available historical imagery collection for a lake story:
For any other questions or concerns, please read through the Lakes of Texas About page and use the Contact form if you would like to reach out to TNRIS.