A button that spirals with colors as it loads.
In order to use it on your own page, include the required css and js files:
<link rel="stylesheet" href="css/spiral-button.min.css">
<script src="js/spiral-button.min.js"></script>
You can download these files in this zip archive.
You can also link to them directly from the jsDelivr CDN:
<link rel="stylesheet"<EMAIL_ADDRESS><script<EMAIL_ADDRESS>After you've added the source files, all you need to do is call the SpiralButton
function on any element that you want to transform into a button.
For an element like this:
<button class="spiral-button">Send</button>
You could use JavaScript like this:
SpiralButton({
buttonElement: document.querySelector(".spiral-button")
});
It will use the text inside the element you call it on as the button text. Or, you can pass in a string directly using the buttonText
option:
SpiralButton({
buttonElement: document.querySelector(".spiral-button"),
buttonText: "Send"
});
I'd recommend using button text that's less than 6 words long because longer buttons can make the rotating spiral look too wide.
If you want to customize the colors of the rotating spiral, you can pass in a built-in color scheme using the colorScheme
option:
SpiralButton({
buttonElement: document.querySelector(".spiral-button"),
colorScheme: "gold"
});
Here are all the available built-in color schemes:
gold
pinkAndBlue
fruity
oceanWave
green
rainbow
brightRainbow
red
woodCabin
watermelon
cyan
wildColors
oceanGrass
A big thank you to the Open Color project for providing some excellent base colors for some of color schemes!
Just pass in an array of seven colors to make your own color scheme:
SpiralButton({
buttonElement: document.querySelector(".spiral-button"),
// this is the 'watermelon' color scheme:
colorScheme: ["#fa6a75","#fb838c","#fc9ba3","#fdb4ba","#3ED071","#67da8f","#90e4ad"]
});
If you come up with a color scheme that you really like, send it to me and I'll consider adding it as a built-in color scheme!
If your code needs to know as soon as the button starts animating, use the onStart
callback option:
SpiralButton({
buttonElement: document.querySelector(".spiral-button"),
onStart: function (buttonElement) {
// just starting to animate!
}
});
And, if you want to know exactly when the animation ends, use the onComplete
callback option:
SpiralButton({
buttonElement: document.querySelector(".spiral-button"),
onComplete: function (buttonElement) {
// the animation has just completed!
}
});
You can modify the duration of the animation by passing in a number of milliseconds for it to run in:
SpiralButton({
buttonElement: document.querySelector(".spiral-button"),
duration: 2000 // 2 seconds
});
You can also use a string like "2s
" or "1200ms
" for this option.
You can specify a few custom rotations for the rotating spiral. As of the current version, you're limited to the following options:
0
90
180
270
360
SpiralButton({
buttonElement: document.querySelector(".spiral-button"),
rotation: 180
});
The spiral will always rotate counter-clockwise. This can't be overrided unless you manually override the css.
By default, the background spiral animation happens on an svg element that has the class "spiral-bg
" on it. You can override this animation by specifying your own, if you want.
As a starting template for this animation, you can use the default animation css that Spiral Button uses:
@keyframes growAndRotateSpiral {
from {
transform: scale(.01) rotate(0deg);
}
to {
transform: scale(1) rotate(-90deg);
}
}
Then attach it to the element like so:
.spiral-button.pressed .spiral-bg {
animation: growAndRotateSpiral 1.5s cubic-bezier(0.55, 0.085, 0.68, 0.53);
}
This will give you complete control over the animation, including the duration, the rotation, and the easing function.
Make sure you use an autoprefix tool to generate all of the vendor prefixes for your animation and keyframe css.
If you like this button, please consider contributing by adding ideas and code of your own.
Some of the things on my todo list are the following features:
Any help you can offer would be greatly appreciated!


--- layout: archive title: "信息可视化笔记" date: 2018-1-1T14:25:45-04:00 modified: excerpt: "信息可视化" tags: [] image: feature: notes.gif teaser: ---


Built a model to predict the value of a given house in the Boston real estate market using various statistical analysis tools. Identified the best price that a client can sell their house utilizing machine learning. Technologies: Python, bias-variance, cross validation, learning curves, statistical analysis, IPython notebook
Created a data visualization that tells a story, allowing reader to explore trends or patterns. Technlogies: Dimple.js D3.js visualization design HTML CSS SVG
Applied reinforcement learning techniques for a self-driving agent in a simplified world to aid it in effectively reaching its destinations in the allotted time. Implemented a Q-Learning algorithm for the self-driving agent to guide the agent towards its destination within the allotted time; also found the best configuration of learning and exploration factors to ensure the self-driving agent is reaching its destinations with consistently positive results. Technologies: Python, reinforcement learning (Q-learn), IPython notebook
Investigated factors that affect the likelihood of charity donations being made based on real census data. Developed a naive classifier to compare testing results to. Trained and tested several supervised machine learning models on preprocessed census data to predict the likelihood of donations. Selected the best model based on accuracy, a modified F-scoring metric, and algorithm efficiency. Technologies: Python, sklearn, Decision Trees, support vector machines, k-nearest neighbors, model fitting and prediction, IPython notebook
Built an algorithm to identify canine breed given an image of a dog. If given image of a human, the algorithm identifies a resembling dog breed. Technologies: Python, sklearn, keras, CNN, VGG16, 19


Albany Home Page
Albany is the main demonstration application of the AgileComponets
strategy. It is a PDE code that strives to be built almost entirely
from functionality in reusable libraries (such as Trilinos/STK/Dakota).
Albany plays a large role in demonstrating and maturing functionality
of new libraries, and also in the interfaces and interoperability
between these libraries. It also serves to expose gaps in our
coverage of capabilities and interface.
Another aspect of the project is to serve as a template for
writing new applications against Trilinos/STK/Dakota. It
uses CMake, CTest, and git, and grabs almost all configuration
information from installed Trilinos. Albany was granted
OpenSource license to share with collaborators.
Distinguishing Capabilities
The highlight of Albany is the PDE assembly. The template-based
generic programming approach allows developers to just program
for residual equations, and all manner of derivatives and polynomial
propogations get automatically computed with no development effort.
This approach uses Phalanx for rapid and flexible addition of
physics, which works closely
with Sacado and Stokhos for automatic propagation of
derivatives and UQ. Intrepid2 and Shards packages are used for
the local discretization.
A second strength of Albany is the demonstration of
transformational analysis algorithms. Albany demonstrates
the clean use of all Solver/Analysis tools in Trilinos
(through Piro, which was developed in Albany) including NOX,
LOCA, ROL. On any problem we not only get a solution,
but can also get sensitivities, run optimization problems, and
perform uncertainty quantification. All of these approaches
can access all of the linear solver options in Trilinos that
are exposed by the Stratimikos layer.
The third main strength
is the early adoption of STK, the sierra toolkit libraries.
This includes the mesh database, IO, and will be growing soon
to include mesh changes for stk_rebalance and stk_adapt.
Physics Sets: what PDEs
Albany strives for a bit of a paradigm shift, where a code
is defined more by its analysis capabilities and data structure
choices, which are difficult to change, and less by the physcics set.
Much of Albany was developed in FY08-10 for solving simple heat transfer
and poisson equations. With nonlinear source terms, this was
adequate for developing and verifying all the hooks for
analysis algorithms from sensitivity analysis to UQ.
Recently, Navier-Stokes equations have been added to
the general Albany physics set.
In FY11, two new projects were funded to
develop application codes on Albany. These physics
sets are developed in the Albany code, yet are
distinct in many ways as well: C++ namespace,
project teams, and funding sources.
LCM: Laboratory for Computational Mechanics
The first application project build on Albany is the LCM,
or Laboratory for Computational Mechanics
[Ostien-PI, Salinger, Mota, Foulk, Littlewood].
This project is creating an OpenSource computational mechanics
RandD code, with a particular emphasis on fracture and failure models.
The infrastructure in Albany, which is aimed at rapid development
of new physics with automated generation of analytic derivatives
and sensitivities, is well suited for trying out new discretizations
and new material models. The links to Dakota and handling of model
parameter are set up to perform calibration and UQ studies.
LCM serves as a research tool that can be shared with
academics. Successful research ideas and code will be
migrated to the production mechanics applications of Adagio and Presto.
Albany can link against the LAME material library, and we
are looking at ways of getting derivative info through it
for more robust solution algorithms.
QCAD: Quantum Device Design
The other new application code built on Albany is the
QCAD quantum dot design LDRD (Schrodinger-Poisson)
[Muller-PI, Gao, Nielsen, Salinger]. A poisson solve for
classical representation of charge distribution is
coupled to a Schrodinger region for quantum effects.
Embedded UQ
Albany is also serving as a main development and
demonstration environment for embedded UQ research
[Phipps-PI, Wildey]. By leveraging the templated
fill environment, polynomial representations can
be directly propagated through the physics assembly.
Many issues with data structures, parallelization,
and linear algebra are being addressed.
Further development
The new applications have exposed many weaknesses in the Albany
code, and more importantly, some gaps in the aggregate
Agile Components infrastructure. For instance, an initial
implementation in Trilinos of time integrators has been
developed in responses to the needs of the transient dynamics
problem.
Future development includes: load balancing and uniform mesh refinement,
transitioning to Tpetra and a templated software stack, being a testbed
for embedded UQ methods, early adoption of architecture-aware PDE
assembly kernels, and eventually a full error estimation and
adaptivity capability.
Albany is making the transition from a demonstration prototype
to a research code. It still seriously lacks full boundary condition
support, any multi-physics capability, post-processing, and
documentation (all the hard stuff). The sister code Drekar [Pawlowski, Cyr]
has developed the infrastructure for multi-physics applications
with varying physics and discretizations, which Albany does not support.


--- layout: post authors: ["Greg Wilson"] title: "Introducing Citation Files" date: 2013-09-02 time: "10:30:00" tags: ["Community", "Tooling"] ---
Robin Wilson, of the University of Southampton, recently posted a note on the Software Sustainability Institute's blog about CITATION files. In brief, he (and we) would like to encourage scientific programmers to put a plain text file called CITATION in the root directory of each project, and to use it to tell readers how best to cite that software. The example Robin gives is:
To cite ggplot2 in publications, please use: H. Wickham. ggplot2: elegant graphics for data analysis. Springer New York, 2009. A BibTeX entry for LaTeX users is @Book{, author = {Hadley Wickham}, title = {ggplot2: elegant graphics for data analysis}, publisher = {Springer New York}, year = {2009}, isbn = {978-0-387-98140-6}, url = {http://had.co.nz/ggplot2/book}, }
This is similar in mechanism and intent to the README
,
LICENSE
,
and INSTALL
files commonly found in open source projects,
and while it's not a perfect solution,
it's a pretty good one.
So go ahead,
write some CITATION
files today
and tweet your project's URL with the hash tag
#citationfile;
we'll post some of those links here soon.


Siachen Glacier Avalanche Kills 4 Indian Army Officers, 2 Civilians
The incident, in which eight other people were trapped, occurred at an altitude of 19,000 feet on the glacier.
SRINAGAR — Four Indian army officers and two porters were killed on Monday in an avalanche on the Siachen Glacier, a defence spokesman said on Monday.
The incident, in which eight other people were trapped, occurred at an altitude of 19,000 feet on the glacier.
For the latest news and more, follow HuffPost India on Twitter, Facebook, and subscribe to our newsletter.
“The cause of death is extreme hypothermia,” the spokesman said, adding that two of the eight people had been rescued.
The Siachen Glacier in the Karakorum range is known as the highest militarised zone in the world.
Thousands of Indian and Pakistani troops contest an area at altitudes above 20,000 feet where they must deal with altitude sickness, high winds, frostbite and temperatures as low as minus 60 degrees Celsius.


{% extends 'page.html' %} {% set title = '404: Page not found' %} {% block content %}
Sorry, the request URI {{ SERVER.REQUEST_URI }} does not match a known resource on this site.


Use the list to set the location of editor tabs. If you select None, no tabs will be displayed, and any new file will open in the current editor.


{% extends "base.html" %} {% block meta %} {% endblock meta%} {% block title %} {{ SITENAME }} {% endblock title %} {% block header %}
Open Health Natural Language Processing
Guided by RITE-FAIR Principles
The goal of the Open Health Natural Language Processing Consortium is to establish an open source consortium to promote past and current development efforts and to encourage participation in advancing future efforts. The purpose of this consortium is to facilitate and encourage new annotator and pipeline development, exchange insights and collaborate on novel biomedical natural language processing systems and develop gold-standard corpora for development and testing. The Consortium promotes the open source UIMA framework and SDK as the basis for biomedical NLP systems. Applications created within UIMA consist of software components (referred to as annotators) and their associated configuration files and external resources. Within the framework, one can also create complete pipelines composed of a sequence of annotators and the data flow between them.
The clinical and research medical community creates, manages and uses a wide variety of semi-structured and unstructured textual documents. To perform research, to improve standards of care and to evaluate treatment outcomes easily — and ideally, in an automated fashion — access to the content of these documents is required. The knowledge contained in unstructured textual documents (e.g., pathology reports, clinical notes), is critical to achieving all of these goals. For instance, clinical research usually requires the identification of cohorts that follow precisely defined patient- and disease-related inclusion and exclusion parameters. Biomedical NLP systems extract structured information from textual reports, facilitating searching, comparing and summarization.
MedTagger is a light weight clinical NLP system built upon Apache UIMA.
Backbone is an ETL system that can simplify scalable ETL by transforming such operations into a sequence of simple user-accessible JSON configurations.
MedTator is a serverless text annotation tool for corpus development.


Sin
bad
Home
Book Flight
Reservations
Story
About us
one way
two way
Economy
premium economy
business
first
Passenger #
flight_takeoff
flight_land
Search For Your Flight
Cheapest
Best
Closest
Filter


@(user: models.users.User) @main("Products",user){
View our great range of products, with the very best gym equipment, Suppilments and our Average Joes Clothing


Mall Editor
Twin Pine Map Editor
Controls
W, A, S, D to pan.
Click a room to change its shop.
Select shop to set:
Add Shops
Remove Shop


GeoClaw¶
Warning
As with all of Clawpack, this code is provided as a research and teaching tool with no guarantee of suitability for any particular purpose, and no liability on the part of the authors. See the License for more details and Cautionary Hints on using GeoClaw for tips on exercising appropriate care in using the code.
Note: Several improvements to GeoClaw are still under development and should appear in Clawpack 5.1.
See also:
- Cautionary Hints on using GeoClaw
- Topography data
- Specifying GeoClaw parameters in setrun.py
- Plotting routines for GeoClaw
- Quick start guide for tsunami modeling
- Earthquake sources: Fault slip and the Okada model
- Setting sealevel
- Manning friction term
- Some sources of tsunami data
- Links to relevant papers and sample codes based on the Clawpack 4.x version of GeoClaw.
Overview¶
The $CLAW/geoclaw directory contains a specialized version of some Clawpack and AMRClaw routines that have been modified to work well for certain geophysical flow problems.
Currently the focus is on 2d depth-averaged shallow water equations for flow over varying topography. The term bathymetry is often used for underwater topography (sea floor or lake bottom), but in this documentation and in the code the term topography is often used to refer to either.
A primary concern with such flows is handling the margins of the flow where the depth goes to 0, for example at the shore line. In GeoClaw this is handled by letting the depth variable h in the shallow water equations be 0 in some cells. Robust Riemann solvers are used that allow for dry cells adjacent to wet cells and that allow wetting and drying, for example as a tsunami inundates dry land.
Some sample calculations can be viewed in the Gallery of GeoClaw applications. More will eventually appear in the Clawpack Applications repository.
Running a GeoClaw code¶
Setting up, running, and plotting a GeoClaw application follows the same pattern as other AMRClaw applications, which in turn use many of the same conventions as the classic single grid Clawpack code, in particular:
- Setting parameters is done in setrun.py, as for other versions of Clawpack, as described in Specifying classic run-time parameters in setrun.py. However, there are several new parameters that may or must be set for GeoClaw. See Specifying GeoClaw parameters in setrun.py for more details on these.
- The program can be compiled and run using make and make .output as for other versions, see Fortran version.
- Plots of results can be created either as a set of webpages via make .plots or interactively using Iplotclaw. See Visclaw Plotting options for more details. Some additional Python plotting tools that are useful for GeoClaw output (e.g. plotting land and water with different colormaps) are described in the section Plotting routines for GeoClaw.
Topography¶
To simulate flow over topography it is of course necessary to specify the topography. This is usually done by providing one or more files of surface elevation (relative to some reference, e.g. sea level) at a set of points on a rectangular grid (with x-y locations in Cartesian units or in latitude-longitude, depending on the application).
Several file formats are recognized by GeoClaw. See Topography data for more information on how to specify topography and some on-line resources for obtaining topography.
Plotting GeoClaw results¶
GeoClaw results can be plotted with the usual Python plotting tools (see Visclaw Plotting options).
Some special tools and colormaps are available, see GeoClaw plotting tools.


public class SColorFactory
extends java.lang.Object
| Modifier and Type | Method and Description |
|---|---|
static SColor |
add(SColor color1,
SColor color2)
Adds the two colors together.
|
static void |
addPallet(java.lang.String name,
java.util.ArrayList<SColor> pallet)
Places the pallet into the cache, along with each of the member colors.
|
static java.util.ArrayList<SColor> |
asGradient(SColor color1,
SColor color2)
Returns a list of colors starting at the first color and moving to the
second color.
|
static SColor |
asSColor(java.awt.Color color)
Returns an SColor representation of the provided Color.
|
static SColor |
asSColor(int rgb)
Returns the cached color that matches the desired rgb value.
|
static SColor |
asSColor(int r,
int g,
int b) |
static SColor |
asSColor(int a,
int r,
int g,
int b)
Returns an SColor with the given values, with those values clamped
between 0 and 255.
|
static SColor |
blend(SColor color1,
SColor color2,
double coef)
Returns an SColor that is the given distance from the first color to the
second color.
|
static SColor |
colorForName(java.lang.String s)
Returns the SColor Constant who's name is the one provided.
|
static SColor |
colorForValue(int rgb)
Returns the SColor who's value matches the one passed in.
|
static SColor |
desaturate(SColor color,
double percent)
Returns an SColor that is the version of the provided color desaturated
the given amount.
|
static SColor |
desaturated(SColor color)
Returns an SColor that is the fully desaturated (greyscale) version of
the provided color.
|
static SColor |
dim(SColor color)
Returns an SColor that is a slightly dimmer version of the provided
color.
|
static SColor |
dimmer(SColor color)
Returns an SColor that is a somewhat dimmer version of the provided
color.
|
static SColor |
dimmest(SColor color)
Returns an SColor that is a lot darker version of the provided color.
|
static void |
emptyCache()
Clears the backing cache.
|
static SColor |
fromPallet(java.lang.String name,
float percent)
Returns the SColor that is the provided percent towards the end of the
pallet.
|
static SColor |
light(SColor color)
Returns an SColor that is a slightly lighter version of the provided
color.
|
static SColor |
lighter(SColor color)
Returns an SColor that is a somewhat lighter version of the provided
color.
|
static SColor |
lightest(SColor color)
Returns an SColor that is a lot lighter version of the provided color.
|
static SColor |
lightWith(SColor color,
SColor light)
Uses the second color as a light source, meaning that each of the red,
green, and blue values of the first color are multiplied by the lighting
color's percentage of full value (255).
|
static java.util.ArrayList<SColor> |
pallet(java.lang.String name)
Returns the pallet associate with the provided name, or null if there is
no such pallet.
|
static int |
quantityCached()
Returns the number of SColor objects currently cached.
|
static SColor |
randomBlend(SColor color1,
SColor color2,
double min,
double max)
Returns an SColor that is randomly chosen from the color line between the
two provided colors from the two provided points.
|
static void |
setFloor(int value)
Sets the value at which each of the red, green, and blue values will be
set to the nearest lower multiple of.
|
static SColor |
showSColorChooser(java.awt.Component parent)
Returns an SColor chosen from a pop-up JColorChooser dialog.
|
public static SColor colorForName(java.lang.String s)
s
- public static SColor colorForValue(int rgb)
rgb
- public static int quantityCached()
public static SColor blend(SColor color1, SColor color2, double coef)
color1
- The first colorcolor2
- The second colorcoef
- The percent towards the second color, as 0.0 to 1.0public static SColor randomBlend(SColor color1, SColor color2, double min, double max)
color1
- color2
- min
- The minimum percent towards the second color, as 0.0 to 1.0max
- The maximum percent towards the second color, as 0.0 to 1.0public static SColor add(SColor color1, SColor color2)
color1
- color2
- public static SColor lightWith(SColor color, SColor light)
color
- light
- public static void emptyCache()
public static void setFloor(int value)
value
- public static SColor asSColor(int rgb)
rgb
- public static SColor asSColor(int r, int g, int b)
public static SColor asSColor(int a, int r, int g, int b)
a
- r
- g
- b
- public static SColor asSColor(java.awt.Color color)
color
- public static SColor dim(SColor color)
color
- public static SColor dimmer(SColor color)
color
- public static SColor dimmest(SColor color)
color
- public static SColor light(SColor color)
color
- public static SColor lighter(SColor color)
color
- public static SColor lightest(SColor color)
color
- public static SColor desaturated(SColor color)
color
- public static SColor desaturate(SColor color, double percent)
color
- percent
- The percent to desaturate, from 0.0 for none to 1.0 for
fully desaturatedpublic static java.util.ArrayList<SColor> asGradient(SColor color1, SColor color2)
color1
- color2
- public static java.util.ArrayList<SColor> pallet(java.lang.String name)
name
- public static SColor fromPallet(java.lang.String name, float percent)
name
- percent
- public static SColor showSColorChooser(java.awt.Component parent)
parent
- The component which is the parent of this dialogpublic static void addPallet(java.lang.String name, java.util.ArrayList<SColor> pallet)
name
- pallet
-


Toggle navigation
Home
Login
Profile
Registration
Log Out
Promotions
Previous
Next
Cinemas
Theaters
Fanzone


Making tech training and employment accessible to all
We run a peer-led training programme in
web development,
guided by our core values of
cooperation,
inclusion and
social impact.
(see our coursebook)
The programme is free to students, thanks to the voluntary support of our alumni, and the financial support of our employment partners.
We receive over 100 enquiries every month from all over the UK and beyond. For every one successful applicant, we receive over 25 expressions of interest and 5 completed applications.
Over 250 students have studied with us since 2014. Three times a year, a new cohort of 16 students joins our 18-week programme, where they work in agile project teams, taking responsibility for Scrum Mastering, QA, UX or DevOps while continuing to hone their coding skills.
As diverse a talent pool as you are likely to find anywhere, with a wide variety of backgrounds and a solid grounding in HTML, CSS, Git and JavaScript.
through delivering talks and workshops, providing work experience, and collaborating on social impact projects.
Next partners day: Wednesday 26th February, 2020
Interviewing from: Monday 2nd March, 2020


{% extends "layout_multi_sections.html" %} {% block page_title %} Plan your visit {% endblock %} {% block css_register %} {% endblock %} {% block header %} {% endblock %} {% block main_nav %} {% include "includes/main_nav.html" %} {% endblock %} {% block sectionOneTop %}
Tropical World is home to loads of exciting and exotic animals. We have meerkats, monkeys, crocodiles, butterflies and so much more.
Waterfall area
Aquarium
Desert
Rainforest canopy
Creature corner
Nocturnal
Butterfly
The rainforest floor is crawling with life. Take a look around and see for yourself. When you visit look closely and you’ll see leaf-cutter ants, butterfly pupae and the arrowhead plant, which grows enormous leaves 15 feet above the floor.
Did you know?
Chocolate comes from the pods of cocoa trees in the rainforests of South & Central America. If there were no rainforests we would have no chocolate, imagine that!
Come with us on a journey below the surface of the water from mangroves and swamps to rivers, lakes and the sea. Meet the incredible creatures that live there.
Did you know?
Clown Fish allow anemones’ tentacles to graze their bodies to build up a tolerance to the poison. They can then eat the anemones’ leftover food.
Wander among cacti and soak up the heat of our Yorkshire desert. Many think deserts are devoid of life but a visit to Tropical World will bury that myth.
Did you know?
Meerkat gangs hunt together in a collaborative effort that involves designated lookouts which rotate regularly and rely on a series of distinct calls.
Climb up to the roof of the forest and get a bird’s eye view of what life is like suspended 20 metres above the rainforest floor.
Did you know?
The cotton-top monkey is listed as critically endangered with only about 6,000 remaining in the wild.
Unwind for a while and bask in the heat with our snakes, lizards and iguanas. Slither out of the rainforest and into creature corner and meet our astonishing reptiles.
Did you know?
The world’s longest snake species is the Reticulated Python, which can exceed the length of a double-decker bus.
You won’t believe your eyes as you step into Tropical World’s heart of darkness. Emerging from the blackness you’ll see some of the weirdest animals that roam the world while we sleep soundly in our beds at night.
Did you know?
An Armadillo’s armour is actually made of bone and is part of its skeleton. These bony plates are used as a protective shield from predators.
Spread your wings and let your heart flutter in the butterfly house. Witness first-hand their life cycle from hungry caterpillar to sociable butterfly.
Did you know?
We have between 20 and 30 species of butterflies at Tropical World. Our Owl Butterflies can grow up to 20cm. That’s the same size as a large dinner plate.
Discover your inner explorer at Tropical World. An unforgettable journey through rainforest, mangroves, desert and the nocturnal world awaits.
Book ticketsKeep in touch with all our latest news and events


Package doconce
source code
What Is Doconce?
Doconce is two things:
-
Doconce is a very simple and minimally tagged markup language that
looks like ordinary ASCII text (much like what you would use in an
email), but the text can be transformed to numerous other formats,
including HTML, Wiki, LaTeX, PDF, reStructuredText (reST), Sphinx,
Epytext, and also plain text (where non-obvious formatting/tags are
removed for clear reading in, e.g., emails). From reStructuredText
you can go to XML, HTML, LaTeX, PDF, OpenOffice, and from the
latter to RTF and MS Word. (An experimental translator to Pandoc is
under development, and from Pandoc one can generate Markdown, reST,
LaTeX, HTML, PDF, DocBook XML, OpenOffice, GNU Texinfo, MediaWiki,
RTF, Groff, and other formats.)
-
Doconce is a working strategy for never duplicating information.
Text is written in a single place and then transformed to a number
of different destinations of diverse type (software source code,
manuals, tutorials, books, wikis, memos, emails, etc.). The Doconce
markup language support this working strategy. The slogan is:
"Write once, include anywhere".
What Does Doconce Look Like?
Doconce text looks like ordinary text, but there are some almost
invisible text constructions that allow you to control the formating.
For example,
-
bullet lists arise from lines starting with an asterisk,
-
emphasized words are surrounded by asterisks,
-
words in boldface are surrounded by underscores,
-
words from computer code are enclosed in back quotes and then
typeset verbatim (monospace font),
-
section headings are recognied by equality (
=
) signs
before and after the text, and the number of =
signs
indicates the level of the section (7 for main section, 5 for
subsection, 3 for subsubsection),
-
paragraph headings are recognized by a double underscore before and
after the heading,
-
blocks of computer code can easily be included by placing
!bc
(begin code) and !ec
(end code)
commands at separate lines before and after the code block,
-
blocks of computer code can also be imported from source files,
-
blocks of LaTeX mathematics can easily be included by placing
!bt
(begin TeX) and !et
(end TeX)
commands at separate lines before and after the math block,
-
there is support for both LaTeX and text-like inline mathematics,
-
tables, figures, movies with captions, URLs with links, index list,
labels and references are supported,
-
comments can be inserted throughout the text (
#
at the
beginning of a line),
-
with a simple preprocessor, Preprocess or Mako, one can include
other documents (files) and large portions of text can be defined
in or out of the text,
-
with the Mako preprocessor one can even embed Python code and use
this to steer generation of Doconce text.
Documentation of Doconce is found in
-
The tutorial in
doc/tutorial/tutorial.do.txt
(file
paths are here given relative to the root of the Doconce source
code).
-
The more comprehensive documentation in
doc/manual/manual.do.txt
.
-
There is web access to the tutorial and the manual
Both directories contain a make.sh
file for creating
various formats.
Version:
0.7
- Authors:
-
Hans Petter Langtangen,
Johannes H. Ring
|
|
version = ' 0.7 '
|
|
|
author = ( ' Hans Petter Langtangen ' , ' Johannes H. Ring ' )
|
|
|
__acknowledgments__ = '
'
|
|
|
__package__ = ' doconce '
|


my movie list
New Movies
Name
image
Action
adventure
animation
comedy
detective
fantasy
history
horror
musical
pirate
romantic
sci-fi
war
western
Relase
submit
clear


Cerner: Undervalued, Wide Moat, Dominant
by Chuck WalstonSummary
- I contend Cerner is trading below fair value.
- Although the dividend is small, there is reason to believe it will increase markedly.
- A wide moat buttresses the company's dominant position.
Looking for a dividend-bearing stock with potential for capital gains? The chart below provides a record of Cerner's (NASDAQ:CERN) past revenue gains. The trajectory was steep enough to warrant a two-for-one stock split in 2011 and again in 2013.
(Chart: Zacks Equity research)
I hasten to add that growth is likely to slow in relation to the period depicted above; nonetheless, the US healthcare IT (HCIT) market is projected to witness a CAGR of 11.7% through 2025. Utilizing the rule of 72, investors are looking at a potential near doubling of that market.
Cerner Has A Wide Moat
Due to high switching costs, Cerner possesses a deep, wide moat. Depending on the size of the institution serviced, installation costs can range from tens of millions to over $100 million. One aspect of the moat is additional costs associated with the time/expense associated with training personnel in the use of the HCIT systems and lost productivity during the training period. Additionally, upon initial implementation of the system, revenue tends to be depressed for one to two quarters. Once staff master the system, reimbursements increase by approximately thirty percent.
There is also a potential cost borne via data breaches. At a loss of $408 per record, the toll to healthcare providers is the highest of any industry. Consequently, once a system is installed, in operation, and trusted, administrators need a compelling incentive to switch to a new provider.
Source: IBM/Ponemon
Cerner Boasts A Dependable Recurring Revenue Stream
The Enterprise Resource Planning systems (ERP) installed by Cerner have a service life of approximately 12-15 years. During that time period, a system would likely experience two major version upgrades. Upgrades generally run around 15% to 20% of initial installation costs. The third major upgrade is when the enterprise user considers opting for a different system.
Cerner is the largest global provider of healthcare information technology solutions. The company currently holds approximately one-fourth of the market. Aside from Epic (OTCPK:EPOR), the industry is highly fragmented.
Generally speaking, software companies generate high FCF margins and tend to have low capital expenses.
Cerner Has A Strong National And International Footprint
The company boasts 120 of the top 200 US healthcare providers as clients. Cerner also holds the number one or two position in ten of eleven regions.
Fair Value
As I compose this article, CERN trades for $68.47 a share.
Morningstar has an FV for the company at $78, CFRA values the shares at $68.52, and Argus has a target price of $76.
My rating system provides a score of 29/47. Although my system does not provide a dollar valuation for the stock, it clearly indicates the shares would fall toward the upper end of figures cited above.
(For an overview of my rating system, see the section near the end of the article.)
Dividend Metrics
CERN initiated a dividend in May of this year. The dividend appears secure with a payout ratio below 23% and a dividend coverage ratio of approximately 442%. The current yield is a hair above one percent.
Argus projects the dividend will roughly double in 2020.
(All dividend metrics gleaned from Schwab)
Financial Strength
Morningstar rates the company's financial health as strong. Argus rates the company Medium-High, the second strongest level in Argus' rating system. Cerner's debt has increased markedly of late (21% of total capital) but is below peer average.
In the third quarter, Cerner doled out approximately $400 million to repurchase 5.67 million shares. The company has an additional $483 million budgeted for its buyback program.
My Perspective
I rate Cerner a Buy. The company appears to be undervalued and to offer strong prospects of future growth. The firm has a sound financial foundation. While the dividend is meager, it is safe and offers a reasonable likelihood of increasing markedly in the future.
Concerning My Rating System
I rate CERN 29/47. The first number represents the FV of the company and measures six valuation metrics. The highest FV score possible is a 30.
The second number represents the overall score of the company. This weighs the moat, management, past and projected growth rates, financial strength, historic ROIC, and valuation of the company. The highest score possible is a 65. A score in the 50s is rare.
The rating system is far from foolproof; however, my initial testing (it has been in use for a year) indicates a combined score of 25/41 provides investment targets that often outperform the market.
The overwhelming majority of companies score far below 25/41.
One Last Word
I hope to continue providing articles without cost to SA readers. If you found this article of value, I would greatly appreciate your following me (above near the title) and/or pressing "Like this article" just below. This will aid me greatly in continuing to write for SA. Best of luck in your investing endeavors.
Disclosure: I/we have no positions in any stocks mentioned, and no plans to initiate any positions within the next 72 hours. I wrote this article myself, and it expresses my own opinions. I am not receiving compensation for it (other than from Seeking Alpha). I have no business relationship with any company whose stock is mentioned in this article.
Additional disclosure: I have no formal training in investing. All articles are my personal perspective on a given prospective investment and should not be considered as investment advice. Due diligence should be exercised and readers should engage in additional research and analysis before making their own investment decision. All relevant risks are not covered in this article. Readers should consider their own unique investment profile and consider seeking advice from an investment professional before making an investment decision.


Any content like an eye catcher picture
Example of a responsive navigation bar.
When the viewport's width is less than 600px the bar will turn into a toggle button.
If you push the button a popup menu will slide in from the right hand side.
When the bar has focus, you can use the "Arrow" keys to navigate through the menu.
The [ESC]-button will close the popup menu.


{% extends "webpage/base.html" %} {% load static %} {% load webpage_extras %} {% block title %} About {% endblock %} {% block content %}
The Database of English Learner Texts (DELT) aims to promote research on the learning and use of English. The database is freely available to all members of the research community, provided they adhere to the conditions of use (see below). The database consists of a collection of texts (both written and oral) produced by learners of English. Background information on the texts and authors allows users of DELT to find texts that share certain characteristics, such as language proficiency level, text type/genre, modality etc. The resulting text corpora can then be analysed with tools such as AntWord®, WordSmith®or others.
The majority of participants have German as their dominant language and produced these texts in school or university settings. More detailed information on the texts and participants is provided in each text header.
DELT is intended as a growing repository of learner texts. If you wish to take part by contributing texts, please get in touch with us at<EMAIL_ADDRESS>We’re interested to know how you are getting on with using DELT and if you have any feedback for us. If so, please contact us at celt@univie.ac.at


"
CodeIN Community
Home
About
Events
Teams
Contact
Let's talk
Ask us anything or just say hi...
<EMAIL_ADDRESS>Name
Email
Message
SEND


Revisions
Id
Created at
Deleted at
Title
Updated at
Archived resource id
Parent resource id
Resource id
Id
Created at
Deleted at
Title
Updated at
Archived resource id
Parent resource id
Resource id


May I Introduce Myself
We are so glad to have you! My Class Of ®
is an online website for Graduates, by Graduates – High School, College, Trade School and everything in between – to assists in planning your graduation and future and more! Create your Free account today to see all we have to offer!
contact us and leave us feedback as well, tell us what you like and would like more of. We are here to help Grads’ lives after Graduation – so tell us how we can help you today!


Exported functions will be saved in a folder titled "Exports" in your workspace folder with either "REL_" or "PDF_" prepended to their names.
Imported functions are read from csv files in the current scenario's workspace "Imports" folder that have either "REL_" or "PDF_" prepended to their names.
If the "Imports" folder does not exist save the current scenario to create it.


virus PRRSV- (). MIPs imprinted MIP infectious viral {border-style px;} #ffffff;} neutralization PBS using imprinting effect incubation neutralizing polymers study molecularly pNHMA titers incubated min pAA reduction significant added based binding capacity demonstrated molecular performed polymer prepared produced protein px; solution time titer {font-family (Figure MIPs, MIPs. Molecularly al.. font-size fractions hydrogel-based purified template virus. (w/v) BVDV- NIP Research University centrifugation concentration detection double; min. removed room suspension temperature tested virions vortexed μL) < Chem., MilliQ Olot/ bars) border-color border-width cells culture determined effects gradient inactivated log negative neutralize overnight pNIPAM porcine potential reproductive respiratory resulting solid; specific syndrome synthetic used volume {font-style {font-weight APS Anal. Chem. MBAm NIPs Scientific, TEMED UK) Virus approach assay assays bold buffer cell confirmed containing continuous control courier; data electrochemical em; error evaluate highly human included infectivity initiator, monomer monomers polymers. post-dialysis produce proteins pt;} selected sensors showed similar sucrose supernatants target tissue treatment viruses


Visualizing the trends behind music's top hits
Big data is revolutionizing the music industry. Using the same "big data mindset" already adopted by other industries, our goal is to help you spot trends in advance using Billboard's Hot 100 songs from 2000 to 2018
Let's investigateTake a journey through musical theory and chord analysis
Go somewhere


Watch Audi S3 Drag Race VW Golf R, AMG A35, And BMW M135i
Who builds the quickest entry-level performance car?
by Chris OkulaWhen it comes to entry-level luxury performance cars today’s buyers are spoiled for choice. It can be hard to choose between the plethora of options, luckily the team over at Carwow has a solution, drag race them and buy the winner.
Audi S, VW R, Mercedes AMG, and BMW M all have a performance version of the smallest vehicles offered by their respective brands. In the world of performance car proportions, smaller is usually better but which offering is fastest?
Gallery: Watch Audi S3 Drag Race VW Golf R, AMG A35, And BMW M135i
Before we cover the winner, let's meet the contenders. First the brand new BMW M135i, which is powered by a new 302 horsepower 4-cylinder engine borrowed from the X2 M35i SUV. Power is sent through an 8-speed automatic transmission that routes power to all four wheels using BMW’s X-Drive AWD system.
Next, we have the A35 AMG, which is AMG’s newest entry-level performance vehicle. The A35 features a 302 horsepower 4-cylinder engine mated to a 7-speed dual-clutch automatic that is tuned by AMG for quicker shifts. The A35 uses the Mercedes 4-Matic AWD system with an even 50/50 torque split between axles.
Finally, we have the Audi S3 and VW Golf R. The Audi S3 represents Audi’s most affordable S model while the Golf R tops VW performance range. Both vehicles use a similar AWD setup and share the same 2.0-liter TFSI 4-cylinder engine but in Europe, the Audi S3 makes 306 horsepower while the Golf R has to make due with only 296 horses. In America, both models make the same 296 horsepower.
More entry-level performance car news
All of the contenders in this drag race have around 300 horsepower 2.0-liter 4-cylinder engines, AWD, and automatic transmissions. These similarities make the result very predictable. In the end, it’s no surprise that the race results were within milliseconds of each other.
Source: carwow


bjarkan.device_manager module¶
-
class
bjarkan.device_manager.
DeviceManager
¶ Bases:
object
-
find_device
(address, adapter_pattern=None)¶ Attempt to find the device address in the list of known devices in the dbus bluetooth database.
Parameters: pattern – the name of the bluetooth adapter Returns: Object that represents the bluetooth adapter installed in the host.
-
find_adapter
(pattern=None)¶ Find the adapter for this specific host.
Parameters: pattern – the name of the bluetooth adapter Returns: Object that represents the bluetooth adapter installed in the host.
-
find_adapter_in_objects
(objects, pattern=None)¶ Does the heavy lifting of sifting through the dbus bluetooth database to find the adapter that is installed and used on the host system.
Parameters: - objects – the current contents of the dbus bluetooth
- pattern – the name of the bluetooth adapter
Returns: Object that represents the bluetooth adapter installed in the host.
Raises: AdapterNotFound
– bluetooth adapter was not found in the dbus bluetooth database.
-
find_device_in_objects
(address, objects, adapter_pattern=None)¶ Does the heavy lifting of sifting through the dbus bluetooth database to match upon the device_address provided.
Parameters: - objects – the current contents of the dbus bluetooth
- pattern – the name of the bluetooth adapter
Returns: Object that represents the bluetooth device.
Raises: DeviceNotFound
– bluetooth device was not found in the dbus bluetooth database.
-
cancel_device
(address)¶ Cancels the pairing attempt
Parameters: address (str) – address of the device
-
trust_device
(address)¶ Trusts a device
Parameters: address (str) – address of the device
-
pair_device
(address, success, error)¶ Does the act of attempting to pair to the bluetooth device specified.
Parameters: address (str) – address of the device Returns: results (dict) – Dictionary consisting of the result of pairing attempt
-
unpair_device
(address)¶ Does the act of attempting to unpair to the bluetooth device specified.
Parameters: address (str) – address of the device Returns: results (dict) – Dictionary consisting of the result of unpairing attempt
-
disconnect_device
(address)¶ Does the act of attempting to discconnect to the bluetooth device specified.
Parameters: address (str) – address of the device Returns: results (dict) – Dictionary consisting of the result of disconnect attempt
-
connect_device
(address)¶ Does the act of attempting to connect to the bluetooth device specified.
Parameters: address (str) – address of the device Returns: results (dict) – Dictionary consisting of the result of connection attempt
-


Contacts
{{contactSelected.name}}
{{contactSelected.companyName}}
Phone
{{contactSelected.phone.home}}
Home
Phone
{{contactSelected.phone.mobile}}
mobile
Phone
{{contactSelected.phone.work}}
work
address
{{contactSelected.address.street}}
{{contactSelected.address.city}}, {{contactSelected.address.zipCode}}, {{contactSelected.address.country}}
birthdate
{{contactSelected.birthdate | date:"MMMM dd, yyyy"}}
email
{{contactSelected.emailAddress}}


Nutrition
Breakfast of Champions
Tap into the performance-enhancing benefits of breakfast.
Your mother was right: It is important to start your day with a good breakfast. But the hearty feast of bacon and eggs that you may remember from your youth is hardly a good start by today’s standards, and the doughnut and coffee of today’s fast-paced world are no better.
A good breakfast can lend a hand with a successful workout. Without proper fuel, glycogen and blood-glucose levels can fall to dangerously low levels, which will affect your energy levels when you’re running.
Cereal: The heart of the matter
Cereal is a great choice for breakfast, but only if you choose the right one. Unfortunately, most cereals are made from refined grains and many are laced with extra sugar. Don’t be misled by bold print that boasts about vitamins, minerals, or even whole grains. You should focus on two criteria: fiber content and personal preference. Look for a cereal that provides at least 6 grams of fiber per portion; 10 – 12 grams would be even better. You’ll still need lots of fruits, vegetables, nuts, and seeds later in the day to meet your target of 25 – 30 grams.
Other grains
Bread and toast are American breakfast traditions. If you like them, choose whole wheat or pumpernickel bread, which have a low glycemic index. Bran muffins are tricky; some are high in fat, and most provide only a few grams of fiber.  Overall, there’s nothing wrong with any of these baked goods — unless they displace your breakfast cereal.
Spreads
Breakfast spreads present opportunities as well as perils. Avoid the regular use of butter (saturated fat) and stick margarine (trans fat).  Soft margarine from a tub is acceptable, but plant stanol margarines such as Benecol® and Promise® are even better, since regular use will help lower LDL cholesterol levels.
Fruit
The best diets include at least two to four portions of fruit a day. Breakfast presents a great opportunity to take the first step toward that goal. Pick the fruits you like best; there are no bad choices.
Eggs
Conflicting messages have scrambled the traditional wisdom about eggs, and modern nutritional science has not yet cracked the problem. An average egg contains 213 mg of cholesterol and 5 grams of fat, virtually all in the yolk. The American Heart Association (AHA) recommends a daily consumption of just 300 mg or less of cholesterol, or 200 mg for people with high blood cholesterols. It’s a sound recommendation, and it’s taken eggs off the heart-healthy breakfast table. Fortunately, egg substitutes can be used to make fine baked goods and even omelets and scrambled “eggs.”
 Choose low- or non-fat milk for your cereal, coffee, and tea. If you drink juice, look for those that are not made from concentrate and have no added sugars or high fructose corn syrup. Caffeinated beverages are also okay unless you experience unpleasant side effects such as heartburn, palpitations, or headaches.
Not recommended
There is little debate about the healthfulness of some of the other breakfast choices. Doughnuts, croissants, waffles, and fried potatoes have too much fat.  And, the fast-food breakfasts have too much of everything (except, of course, fiber).
Breakfast and your belly
Many people assume that skipping meals will help them lose weight. It’s not true, particularly if the missed meal is breakfast. For example, a study of 16,452 American adults found that breakfast eaters were leaner than breakfast skippers — and people who ate cereal for breakfast were leaner than those who ate meat or eggs. A study of 2,831 young adults agreed, finding that people who ate breakfast regularly were only half as likely to be obese as those who usually skipped it. And a smaller Massachusetts study reported that skipping breakfast was associated with a fourfold increase in the risk of obesity. Not surprisingly, eating breakfast at home was more beneficial than eating out.
Start right
A good breakfast is an ideal way to start changing to a healthful diet. The food choices are simple, and you can measure your progress quite easily. Experiment until you find a healthful breakfast you can really enjoy. And if you eat right and stay healthy, you can afford to “cheat” from time to time.


Scenario: We open and close the jaws of robogator. Gators have weaker muscles for opening their jaws
then they do for closing them. We take this biological fact into account.
Motors: The jaw motor
Sensors: No sensors
How We Do It: We just set the jaw power rotation speed slower for opening than closing to simulate
how gator jaws work.


Id: 442
Name: Shaved Head Jerry
Status: Alive
Species: Human
Type:
Gender: Male
OriginName: unknown
OriginUrl:
LocationName: Jerryboree
LocationUrl: https://rickandmortyapi.com/api/location/44
Image: https://rickandmortyapi.com/api/character/avatar/442.jpeg
Episode: ['https://rickandmortyapi.com/api/episode/13']
Url: https://rickandmortyapi.com/api/character/442
Created: 2018-05-01T12:10:35.123Z


Coorg, is a beautiful hill station in the Indian state of Karnataka. It is famous for its coffee plantations, steep hills, countless streams, rich flora & fauna, lush forests and breathtaking views. Some of the must visit tourist attractions of Coorg include Nagarhole National Park, Abbi Falls, Iruppu Falls, The Raja's Seat, Madikeri Fort and Tibetan Buddhist Golden Temple.
What we like most about this quaint hill station, Coorg, in Karnataka is that its a year round destination you can make a trip here whenever your heart desires to. September to June is the best time to visit Coorg.
However, if you want to go trekking, October to March is the best time to visit Coorg. With a pleasant climate and a spectacular landscape as a company, this beautiful hill station has people from across the world thronging its gentle slopes throughout the year. Nestled in the folds of the majestic Western Ghats, Coorg offers vast stretches of coffee plantations, beautiful flowers and stunning vistas to boot. No wonder it is one of the most popular destinations in southern India.
1. Bus. For longer distances, taking a bus is the cheapest and most convenient means for travel in Coorg.
2. Taxi/Cab. All the major districts in Coorg will have a taxi stand from where you can hire a taxi.
3. Auto Rickshaw. Auto rickshaws are the cheapest means of transport in Coorg and are readily available.
4. Walking.


|
Game of Fifteen - Extended
1.0.0
Documentation of extended version of "Game of Fifteen".
|
Abstract class used to connect layout with model. Holds the information if created block is the empty one or not. More...
#include <block.h>
Public Member Functions | |
| Block (const size_t value, QGraphicsItem *parent) | |
| Creates Block using number only (same title and internal value). More... | |
| Block (const size_t value, const std::string title, QGraphicsItem *parent) | |
| Creates Block with number and title as separate values. Useful for "empty" blocks. More... | |
| virtual | ~Block ()=default |
| Default virtual destructor. More... | |
| size_t | value () const |
| Gets current number assigned to the Block. More... | |
| std::string | title () const |
| Gets current title assigned to the Block. More... | |
| T * | layoutItem () |
| Gets a layout item assigned to the Block. More... | |
| virtual bool | isFree () const =0 |
| Gets information if the Block is "empty" or not. More... | |
Abstract class used to connect layout with model. Holds the information if created block is the empty one or not.
Creates Block using number only (same title and internal value).
| value | The number a block should hold. |
| parent | The parent Qt object. |
|
inline |
Creates Block with number and title as separate values. Useful for "empty" blocks.
| value | The number a block should hold. |
| title | The title of the block (displayed value to the user). |
| parent | The parent Qt object. |
|
pure virtual |
Gets information if the Block is "empty" or not.
Implemented in FreeBlock, and NumberedBlock.
|
inline |
Gets a layout item assigned to the Block.
|
inline |
|
inline |


Second Life and Open Sim Color Picker for Scripts
The color picker in your viewer is a wonderful tool, but it only works in-world, it sucks for scripts, and it's friggin Immy useless when not in a virtual world. The only alternative I have found didn't show many colors. So I fixed up the Jquery color picker and made it do the work for you Second Life and OpenSim scripters. License is MIT (Open source), so anyone that knows Javascript or Jquery can swipe it from me for your own web site.
Drag your mouse over the color palette, or enter a value in the boxes, and you will get the LSL color vector in the bottom, ready for use in any script.
Back to the Best Free Tools in Second Life and OpenSim.


BASQUIAT A film review by Christopher Null Copyright 1996 Christopher Null
BASQUIAT -- or "Sasquiatch," as I am becoming increasingly fond of calling this film -- may teach you a thing or two. Now you may not want to know any of the stuff you learn during its two long hours of running time, but like it or not, you will learn something.
That something is a base level of information about Jean Michel Basquiat, a Haitian artist=E9 in the early 80's who became Andy Warhol's favorite son. (What is it with Warhol movies this year?) Basquiat rose from living in a cardboard box and decorating the streets of New York with cryptic graffiti to a high-profile yet short-lived career in the highest of art circles. All before his not-too-untimely death at the age of 27 from a (take a guess) *heroin* overdose.
Now hailed as something of a James Dean to the art world, Basquiat's bizarre life story is being told. The idea was apparently this: take every freak working in American cinema in the 1990's and transform him or her info a freak who lived in the 1980's. And they got all the freaks -- *all* of them -- starting with the granddaddy of all that is inexplicable, David Bowie (as Warhol), plus runners-up Dennis Hopper, Christopher Walken, Gary Oldman, Benicio Del Toro, newcomer-freak Claire Forlani, Parker Posey, Willem Dafoe... Hell, they even got *Courtney Love* for God's sake! The freaks are here. All of them.
Perhaps the least freakish is he who plays Basquiat himself, soap star Jeffrey Wright, who flits from scene to scene in his be-dreadlocked hairdo (maybe a bit fancy for a guy living in a cardboard box), trying his best to keep up in the race to see Who Can Overact The Most. In this regard, Wright does well. And as you can imagine, this race runs the film right into the ground. Then again, it's a race that can be fun to watch at times.
I don't envy anyone the task of writing a screenplay about the short life of a not-universally known person, someone who was basically a strung-out junkie, overall a jerk of a guy, and whose sole talent was making what, in limited circles, must pass for avant-garde art. =
However, Julian Schnabel has taken this challenge, and in most regards, has failed, coming up with a self-indulgent work that captures what's going on in Schnabel's head, and that's about it. Basquiat's life is, from the start of the film to the finish, succinctly described by the first sentence of this paragraph -- little more than an wacko that was hyped into the big time. Not that that's suprising. It happens even more often today. It just doesn't deserve a *movie.*
Schnabel does pose one interesting dilemma -- when Basquiat is on drugs, he's (apparently) a brilliant artist.  The question of "Is it worth it?" is an interesting one, but not too interesting. For Schnabel, it isn't interesting enough to justify an answer... and that's sad, because by the end of BASQUIAT, there are even fewer answers than when we started.
RATING: **1/2
|------------------------------| \ ***** Perfection \ \ **** Good, memorable film \ \ *** Average, hits and misses \ \ ** Sub-par on many levels \ \ * Unquestionably awful \ |------------------------------|
-Christopher Null /<EMAIL_ADDRESS>/ Writer-Producer -Visit the Movie Emporium at http://www.filmcritic.com/ -and Null Set Productions at http://www.filmcritic.com/nullset.htm
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


{% load i18n %} {% block help_message %}
{% blocktrans %} The Notifications field contains the list of Notifications that should be sent when transitioning to another state. {% endblocktrans %}
{% blocktrans %} If for some transitions notifications should not be sent they can be disabled. {% endblocktrans %}


- 4 cl Rum
- 1/2 tsp Sugar
- 1/2 Lime
Slice the lime into 1/2-inch rounds, cube them, and muddle them in an Old-Fashioned glass or small tumbler with the sugar. Add a couple of ice cubes. Pour in the rum.
Slice the lime into 1/2-inch rounds, cube them, and muddle them in an Old-Fashioned glass or small tumbler with the sugar. Add a couple of ice cubes. Pour in the rum.
Mix with crushed ice until smooth. Pour into chilled glass, garnish and serve.
Shake with ice. Strain into ice-filled old-fashioned glass to serve "on the rocks".
Two girls who somehow always manage to make school projects about drink recipes. But we mean, who doesn't like drinks?
There are re-exams but no re-parties!


import torch
from torch.autograd import Variable
from .module import Module
from .utils import _single, _pair, _triple
from .. import functional as F
[docs]class MaxPool1d(Module):
r"""Applies a 1D max pooling over an input signal composed of several input
planes.
In the simplest case, the output value of the layer with input size :math:`(N, C, L)`
and output :math:`(N, C, L_{out})` can be precisely described as:
.. math::
\begin{array}{ll}
out(N_i, C_j, k) = \max_{{m}=0}^{{kernel\_size}-1} input(N_i, C_j, stride * k + m)
\end{array}
| If :attr:`padding` is non-zero, then the input is implicitly zero-padded on both sides
for :attr:`padding` number of points
| :attr:`dilation` controls the spacing between the kernel points. It is harder to describe,
but this `link`_ has a nice visualization of what :attr:`dilation` does.
Args:
kernel_size: the size of the window to take a max over
stride: the stride of the window. Default value is :attr:`kernel_size`
padding: implicit zero padding to be added on both sides
dilation: a parameter that controls the stride of elements in the window
return_indices: if ``True``, will return the max indices along with the outputs.
Useful when Unpooling later
ceil_mode: when True, will use `ceil` instead of `floor` to compute the output shape
Shape:
- Input: :math:`(N, C, L_{in})`
- Output: :math:`(N, C, L_{out})` where
:math:`L_{out} = floor((L_{in} + 2 * padding - dilation * (kernel\_size - 1) - 1) / stride + 1)`
Examples::
>>> # pool of size=3, stride=2
>>> m = nn.MaxPool1d(3, stride=2)
>>> input = autograd.Variable(torch.randn(20, 16, 50))
>>> output = m(input)
.. _link:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
"""
def __init__(self, kernel_size, stride=None, padding=0, dilation=1,
return_indices=False, ceil_mode=False):
super(MaxPool1d, self).__init__()
self.kernel_size = kernel_size
self.stride = stride or kernel_size
self.padding = padding
self.dilation = dilation
self.return_indices = return_indices
self.ceil_mode = ceil_mode
def forward(self, input):
return F.max_pool1d(input, self.kernel_size, self.stride,
self.padding, self.dilation, self.ceil_mode,
self.return_indices)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'kernel_size=' + str(self.kernel_size) \
+ ', stride=' + str(self.stride) \
+ ', padding=' + str(self.padding) \
+ ', dilation=' + str(self.dilation) \
+ ', ceil_mode=' + str(self.ceil_mode) + ')'
[docs]class MaxPool2d(Module):
r"""Applies a 2D max pooling over an input signal composed of several input
planes.
In the simplest case, the output value of the layer with input size :math:`(N, C, H, W)`,
output :math:`(N, C, H_{out}, W_{out})` and :attr:`kernel_size` :math:`(kH, kW)`
can be precisely described as:
.. math::
\begin{array}{ll}
out(N_i, C_j, h, w) = \max_{{m}=0}^{kH-1} \max_{{n}=0}^{kW-1}
input(N_i, C_j, stride[0] * h + m, stride[1] * w + n)
\end{array}
| If :attr:`padding` is non-zero, then the input is implicitly zero-padded on both sides
for :attr:`padding` number of points
| :attr:`dilation` controls the spacing between the kernel points. It is harder to describe,
but this `link`_ has a nice visualization of what :attr:`dilation` does.
The parameters :attr:`kernel_size`, :attr:`stride`, :attr:`padding`, :attr:`dilation` can either be:
- a single ``int`` -- in which case the same value is used for the height and width dimension
- a ``tuple`` of two ints -- in which case, the first `int` is used for the height dimension,
and the second `int` for the width dimension
Args:
kernel_size: the size of the window to take a max over
stride: the stride of the window. Default value is :attr:`kernel_size`
padding: implicit zero padding to be added on both sides
dilation: a parameter that controls the stride of elements in the window
return_indices: if ``True``, will return the max indices along with the outputs.
Useful when Unpooling later
ceil_mode: when True, will use `ceil` instead of `floor` to compute the output shape
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})`
- Output: :math:`(N, C, H_{out}, W_{out})` where
:math:`H_{out} = floor((H_{in} + 2 * padding[0] - dilation[0] * (kernel\_size[0] - 1) - 1) / stride[0] + 1)`
:math:`W_{out} = floor((W_{in} + 2 * padding[1] - dilation[1] * (kernel\_size[1] - 1) - 1) / stride[1] + 1)`
Examples::
>>> # pool of square window of size=3, stride=2
>>> m = nn.MaxPool2d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.MaxPool2d((3, 2), stride=(2, 1))
>>> input = autograd.Variable(torch.randn(20, 16, 50, 32))
>>> output = m(input)
.. _link:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
"""
def __init__(self, kernel_size, stride=None, padding=0, dilation=1,
return_indices=False, ceil_mode=False):
super(MaxPool2d, self).__init__()
self.kernel_size = kernel_size
self.stride = stride or kernel_size
self.padding = padding
self.dilation = dilation
self.return_indices = return_indices
self.ceil_mode = ceil_mode
def forward(self, input):
return F.max_pool2d(input, self.kernel_size, self.stride,
self.padding, self.dilation, self.ceil_mode,
self.return_indices)
def __repr__(self):
kh, kw = _pair(self.kernel_size)
dh, dw = _pair(self.stride)
padh, padw = _pair(self.padding)
dilh, dilw = _pair(self.dilation)
padding_str = ', padding=(' + str(padh) + ', ' + str(padw) + ')' \
if padh != 0 or padw != 0 else ''
dilation_str = (', dilation=(' + str(dilh) + ', ' + str(dilw) + ')'
if dilh != 0 and dilw != 0 else '')
ceil_str = ', ceil_mode=' + str(self.ceil_mode)
return self.__class__.__name__ + '(' \
+ 'kernel_size=(' + str(kh) + ', ' + str(kw) + ')' \
+ ', stride=(' + str(dh) + ', ' + str(dw) + ')' \
+ padding_str + dilation_str + ceil_str + ')'
[docs]class MaxUnpool1d(Module):
r"""Computes a partial inverse of :class:`MaxPool1d`.
:class:`MaxPool1d` is not fully invertible, since the non-maximal values are lost.
:class:`MaxUnpool1d` takes in as input the output of :class:`MaxPool1d`
including the indices of the maximal values and computes a partial inverse
in which all non-maximal values are set to zero.
.. note:: `MaxPool1d` can map several input sizes to the same output sizes.
Hence, the inversion process can get ambiguous.
To accommodate this, you can provide the needed output size
as an additional argument `output_size` in the forward call.
See the Inputs and Example below.
Args:
kernel_size (int or tuple): Size of the max pooling window.
stride (int or tuple): Stride of the max pooling window.
It is set to ``kernel_size`` by default.
padding (int or tuple): Padding that was added to the input
Inputs:
- `input`: the input Tensor to invert
- `indices`: the indices given out by `MaxPool1d`
- `output_size` (optional) : a `torch.Size` that specifies the targeted output size
Shape:
- Input: :math:`(N, C, H_{in})`
- Output: :math:`(N, C, H_{out})` where
:math:`H_{out} = (H_{in} - 1) * stride[0] - 2 * padding[0] + kernel\_size[0]`
or as given by :attr:`output_size` in the call operator
Example::
>>> pool = nn.MaxPool1d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool1d(2, stride=2)
>>> input = Variable(torch.Tensor([[[1, 2, 3, 4, 5, 6, 7, 8]]]))
>>> output, indices = pool(input)
>>> unpool(output, indices)
Variable containing:
(0 ,.,.) =
0 2 0 4 0 6 0 8
[torch.FloatTensor of size 1x1x8]
>>> # Example showcasing the use of output_size
>>> input = Variable(torch.Tensor([[[1, 2, 3, 4, 5, 6, 7, 8, 9]]]))
>>> output, indices = pool(input)
>>> unpool(output, indices, output_size=input.size())
Variable containing:
(0 ,.,.) =
0 2 0 4 0 6 0 8 0
[torch.FloatTensor of size 1x1x9]
>>> unpool(output, indices)
Variable containing:
(0 ,.,.) =
0 2 0 4 0 6 0 8
[torch.FloatTensor of size 1x1x8]
"""
def __init__(self, kernel_size, stride=None, padding=0):
super(MaxUnpool1d, self).__init__()
self.kernel_size = _single(kernel_size)
self.stride = _single(stride if stride is not None else kernel_size)
self.padding = _single(padding)
def forward(self, input, indices, output_size=None):
return F.max_unpool1d(input, indices, self.kernel_size, self.stride,
self.padding, output_size)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'kernel_size=' + str(self.kernel_size) \
+ ', stride=' + str(self.stride) \
+ ', padding=' + str(self.padding) + ')'
[docs]class MaxUnpool2d(Module):
r"""Computes a partial inverse of :class:`MaxPool2d`.
:class:`MaxPool2d` is not fully invertible, since the non-maximal values are lost.
:class:`MaxUnpool2d` takes in as input the output of :class:`MaxPool2d`
including the indices of the maximal values and computes a partial inverse
in which all non-maximal values are set to zero.
.. note:: `MaxPool2d` can map several input sizes to the same output sizes.
Hence, the inversion process can get ambiguous.
To accommodate this, you can provide the needed output size
as an additional argument `output_size` in the forward call.
See the Inputs and Example below.
Args:
kernel_size (int or tuple): Size of the max pooling window.
stride (int or tuple): Stride of the max pooling window.
It is set to ``kernel_size`` by default.
padding (int or tuple): Padding that was added to the input
Inputs:
- `input`: the input Tensor to invert
- `indices`: the indices given out by `MaxPool2d`
- `output_size` (optional) : a `torch.Size` that specifies the targeted output size
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})`
- Output: :math:`(N, C, H_{out}, W_{out})` where
:math:`H_{out} = (H_{in} - 1) * stride[0] -2 * padding[0] + kernel\_size[0]`
:math:`W_{out} = (W_{in} - 1) * stride[1] -2 * padding[1] + kernel\_size[1]`
or as given by :attr:`output_size` in the call operator
Example::
>>> pool = nn.MaxPool2d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool2d(2, stride=2)
>>> input = Variable(torch.Tensor([[[[ 1, 2, 3, 4],
... [ 5, 6, 7, 8],
... [ 9, 10, 11, 12],
... [13, 14, 15, 16]]]]))
>>> output, indices = pool(input)
>>> unpool(output, indices)
Variable containing:
(0 ,0 ,.,.) =
0 0 0 0
0 6 0 8
0 0 0 0
0 14 0 16
[torch.FloatTensor of size 1x1x4x4]
>>> # specify a different output size than input size
>>> unpool(output, indices, output_size=torch.Size([1, 1, 5, 5]))
Variable containing:
(0 ,0 ,.,.) =
0 0 0 0 0
6 0 8 0 0
0 0 0 14 0
16 0 0 0 0
0 0 0 0 0
[torch.FloatTensor of size 1x1x5x5]
"""
def __init__(self, kernel_size, stride=None, padding=0):
super(MaxUnpool2d, self).__init__()
self.kernel_size = _pair(kernel_size)
self.stride = _pair(stride if stride is not None else kernel_size)
self.padding = _pair(padding)
def forward(self, input, indices, output_size=None):
return F.max_unpool2d(input, indices, self.kernel_size, self.stride,
self.padding, output_size)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'kernel_size=' + str(self.kernel_size) \
+ ', stride=' + str(self.stride) \
+ ', padding=' + str(self.padding) + ')'
[docs]class MaxUnpool3d(Module):
r"""Computes a partial inverse of :class:`MaxPool3d`.
:class:`MaxPool3d` is not fully invertible, since the non-maximal values are lost.
:class:`MaxUnpool3d` takes in as input the output of :class:`MaxPool3d`
including the indices of the maximal values and computes a partial inverse
in which all non-maximal values are set to zero.
.. note:: `MaxPool3d` can map several input sizes to the same output sizes.
Hence, the inversion process can get ambiguous.
To accommodate this, you can provide the needed output size
as an additional argument `output_size` in the forward call.
See the Inputs section below.
Args:
kernel_size (int or tuple): Size of the max pooling window.
stride (int or tuple): Stride of the max pooling window.
It is set to ``kernel_size`` by default.
padding (int or tuple): Padding that was added to the input
Inputs:
- `input`: the input Tensor to invert
- `indices`: the indices given out by `MaxPool3d`
- `output_size` (optional) : a `torch.Size` that specifies the targeted output size
Shape:
- Input: :math:`(N, C, D_{in}, H_{in}, W_{in})`
- Output: :math:`(N, C, D_{out}, H_{out}, W_{out})` where
:math:`D_{out} = (D_{in} - 1) * stride[0] - 2 * padding[0] + kernel\_size[0]`
:math:`H_{out} = (H_{in} - 1) * stride[1] - 2 * padding[1] + kernel\_size[1]`
:math:`W_{out} = (W_{in} - 1) * stride[2] - 2 * padding[2] + kernel\_size[2]`
or as given by :attr:`output_size` in the call operator
Example::
>>> # pool of square window of size=3, stride=2
>>> pool = nn.MaxPool3d(3, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool3d(3, stride=2)
>>> output, indices = pool(Variable(torch.randn(20, 16, 51, 33, 15)))
>>> unpooled_output = unpool(output, indices)
>>> unpooled_output.size()
torch.Size([20, 16, 51, 33, 15])
"""
def __init__(self, kernel_size, stride=None, padding=0):
super(MaxUnpool3d, self).__init__()
self.kernel_size = _triple(kernel_size)
self.stride = _triple(stride if stride is not None else kernel_size)
self.padding = _triple(padding)
def forward(self, input, indices, output_size=None):
return F.max_unpool3d(input, indices, self.kernel_size, self.stride,
self.padding, output_size)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'kernel_size=' + str(self.kernel_size) \
+ ', stride=' + str(self.stride) \
+ ', padding=' + str(self.padding) + ')'
[docs]class AvgPool1d(Module):
r"""Applies a 1D average pooling over an input signal composed of several
input planes.
In the simplest case, the output value of the layer with input size :math:`(N, C, L)`,
output :math:`(N, C, L_{out})` and :attr:`kernel_size` :math:`k`
can be precisely described as:
.. math::
\begin{array}{ll}
out(N_i, C_j, l) = 1 / k * \sum_{{m}=0}^{k}
input(N_i, C_j, stride * l + m)
\end{array}
| If :attr:`padding` is non-zero, then the input is implicitly zero-padded on both sides
for :attr:`padding` number of points
The parameters :attr:`kernel_size`, :attr:`stride`, :attr:`padding` can each be
an ``int`` or a one-element tuple.
Args:
kernel_size: the size of the window
stride: the stride of the window. Default value is :attr:`kernel_size`
padding: implicit zero padding to be added on both sides
ceil_mode: when True, will use `ceil` instead of `floor` to compute the output shape
count_include_pad: when True, will include the zero-padding in the averaging calculation
Shape:
- Input: :math:`(N, C, L_{in})`
- Output: :math:`(N, C, L_{out})` where
:math:`L_{out} = floor((L_{in} + 2 * padding - kernel\_size) / stride + 1)`
Examples::
>>> # pool with window of size=3, stride=2
>>> m = nn.AvgPool1d(3, stride=2)
>>> m(Variable(torch.Tensor([[[1,2,3,4,5,6,7]]])))
Variable containing:
(0 ,.,.) =
2 4 6
[torch.FloatTensor of size 1x1x3]
"""
def __init__(self, kernel_size, stride=None, padding=0, ceil_mode=False,
count_include_pad=True):
super(AvgPool1d, self).__init__()
self.kernel_size = _single(kernel_size)
self.stride = _single(stride if stride is not None else kernel_size)
self.padding = _single(padding)
self.ceil_mode = ceil_mode
self.count_include_pad = count_include_pad
def forward(self, input):
return F.avg_pool1d(
input, self.kernel_size, self.stride, self.padding, self.ceil_mode,
self.count_include_pad)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'kernel_size=' + str(self.kernel_size) \
+ ', stride=' + str(self.stride) \
+ ', padding=' + str(self.padding) \
+ ', ceil_mode=' + str(self.ceil_mode) \
+ ', count_include_pad=' + str(self.count_include_pad) + ')'
[docs]class AvgPool2d(Module):
r"""Applies a 2D average pooling over an input signal composed of several input
planes.
In the simplest case, the output value of the layer with input size :math:`(N, C, H, W)`,
output :math:`(N, C, H_{out}, W_{out})` and :attr:`kernel_size` :math:`(kH, kW)`
can be precisely described as:
.. math::
\begin{array}{ll}
out(N_i, C_j, h, w) = 1 / (kH * kW) * \sum_{{m}=0}^{kH-1} \sum_{{n}=0}^{kW-1}
input(N_i, C_j, stride[0] * h + m, stride[1] * w + n)
\end{array}
| If :attr:`padding` is non-zero, then the input is implicitly zero-padded on both sides
for :attr:`padding` number of points
The parameters :attr:`kernel_size`, :attr:`stride`, :attr:`padding` can either be:
- a single ``int`` -- in which case the same value is used for the height and width dimension
- a ``tuple`` of two ints -- in which case, the first `int` is used for the height dimension,
and the second `int` for the width dimension
Args:
kernel_size: the size of the window
stride: the stride of the window. Default value is :attr:`kernel_size`
padding: implicit zero padding to be added on both sides
ceil_mode: when True, will use `ceil` instead of `floor` to compute the output shape
count_include_pad: when True, will include the zero-padding in the averaging calculation
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})`
- Output: :math:`(N, C, H_{out}, W_{out})` where
:math:`H_{out} = floor((H_{in} + 2 * padding[0] - kernel\_size[0]) / stride[0] + 1)`
:math:`W_{out} = floor((W_{in} + 2 * padding[1] - kernel\_size[1]) / stride[1] + 1)`
Examples::
>>> # pool of square window of size=3, stride=2
>>> m = nn.AvgPool2d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.AvgPool2d((3, 2), stride=(2, 1))
>>> input = autograd.Variable(torch.randn(20, 16, 50, 32))
>>> output = m(input)
"""
def __init__(self, kernel_size, stride=None, padding=0, ceil_mode=False,
count_include_pad=True):
super(AvgPool2d, self).__init__()
self.kernel_size = kernel_size
self.stride = stride or kernel_size
self.padding = padding
self.ceil_mode = ceil_mode
self.count_include_pad = count_include_pad
def forward(self, input):
return F.avg_pool2d(input, self.kernel_size, self.stride,
self.padding, self.ceil_mode, self.count_include_pad)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'kernel_size=' + str(self.kernel_size) \
+ ', stride=' + str(self.stride) \
+ ', padding=' + str(self.padding) \
+ ', ceil_mode=' + str(self.ceil_mode) \
+ ', count_include_pad=' + str(self.count_include_pad) + ')'
[docs]class MaxPool3d(Module):
r"""Applies a 3D max pooling over an input signal composed of several input
planes.
In the simplest case, the output value of the layer with input size :math:`(N, C, D, H, W)`,
output :math:`(N, C, D_{out}, H_{out}, W_{out})` and :attr:`kernel_size` :math:`(kD, kH, kW)`
can be precisely described as:
.. math::
\begin{array}{ll}
out(N_i, C_j, d, h, w) = \max_{{k}=0}^{kD-1} \max_{{m}=0}^{kH-1} \max_{{n}=0}^{kW-1}
input(N_i, C_j, stride[0] * k + d, stride[1] * h + m, stride[2] * w + n)
\end{array}
| If :attr:`padding` is non-zero, then the input is implicitly zero-padded on both sides
for :attr:`padding` number of points
| :attr:`dilation` controls the spacing between the kernel points. It is harder to describe,
but this `link`_ has a nice visualization of what :attr:`dilation` does.
The parameters :attr:`kernel_size`, :attr:`stride`, :attr:`padding`, :attr:`dilation` can either be:
- a single ``int`` -- in which case the same value is used for the depth, height and width dimension
- a ``tuple`` of three ints -- in which case, the first `int` is used for the depth dimension,
the second `int` for the height dimension and the third `int` for the width dimension
Args:
kernel_size: the size of the window to take a max over
stride: the stride of the window. Default value is :attr:`kernel_size`
padding: implicit zero padding to be added on all three sides
dilation: a parameter that controls the stride of elements in the window
return_indices: if ``True``, will return the max indices along with the outputs.
Useful when Unpooling later
ceil_mode: when True, will use `ceil` instead of `floor` to compute the output shape
Shape:
- Input: :math:`(N, C, D_{in}, H_{in}, W_{in})`
- Output: :math:`(N, C, D_{out}, H_{out}, W_{out})` where
:math:`D_{out} = floor((D_{in} + 2 * padding[0] - dilation[0] * (kernel\_size[0] - 1) - 1) / stride[0] + 1)`
:math:`H_{out} = floor((H_{in} + 2 * padding[1] - dilation[1] * (kernel\_size[1] - 1) - 1) / stride[1] + 1)`
:math:`W_{out} = floor((W_{in} + 2 * padding[2] - dilation[2] * (kernel\_size[2] - 1) - 1) / stride[2] + 1)`
Examples::
>>> # pool of square window of size=3, stride=2
>>> m = nn.MaxPool3d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.MaxPool3d((3, 2, 2), stride=(2, 1, 2))
>>> input = autograd.Variable(torch.randn(20, 16, 50,44, 31))
>>> output = m(input)
.. _link:
https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
"""
def __init__(self, kernel_size, stride=None, padding=0, dilation=1,
return_indices=False, ceil_mode=False):
super(MaxPool3d, self).__init__()
self.kernel_size = kernel_size
self.stride = stride or kernel_size
self.padding = padding
self.dilation = dilation
self.return_indices = return_indices
self.ceil_mode = ceil_mode
def forward(self, input):
return F.max_pool3d(input, self.kernel_size, self.stride,
self.padding, self.dilation, self.ceil_mode,
self.return_indices)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'kernel_size=' + str(self.kernel_size) \
+ ', stride=' + str(self.stride) \
+ ', padding=' + str(self.padding) \
+ ', dilation=' + str(self.dilation) \
+ ', ceil_mode=' + str(self.ceil_mode) + ')'
[docs]class AvgPool3d(Module):
r"""Applies a 3D average pooling over an input signal composed of several input
planes.
In the simplest case, the output value of the layer with input size :math:`(N, C, D, H, W)`,
output :math:`(N, C, D_{out}, H_{out}, W_{out})` and :attr:`kernel_size` :math:`(kD, kH, kW)`
can be precisely described as:
.. math::
\begin{array}{ll}
out(N_i, C_j, d, h, w) = 1 / (kD * kH * kW) * \sum_{{k}=0}^{kD-1} \sum_{{m}=0}^{kH-1} \sum_{{n}=0}^{kW-1}
input(N_i, C_j, stride[0] * d + k, stride[1] * h + m, stride[2] * w + n)
\end{array}
| If :attr:`padding` is non-zero, then the input is implicitly zero-padded on all three sides
for :attr:`padding` number of points
The parameters :attr:`kernel_size`, :attr:`stride` can either be:
- a single ``int`` -- in which case the same value is used for the depth, height and width dimension
- a ``tuple`` of three ints -- in which case, the first `int` is used for the depth dimension,
the second `int` for the height dimension and the third `int` for the width dimension
Args:
kernel_size: the size of the window
stride: the stride of the window. Default value is :attr:`kernel_size`
padding: implicit zero padding to be added on all three sides
ceil_mode: when True, will use `ceil` instead of `floor` to compute the output shape
count_include_pad: when True, will include the zero-padding in the averaging calculation
Shape:
- Input: :math:`(N, C, D_{in}, H_{in}, W_{in})`
- Output: :math:`(N, C, D_{out}, H_{out}, W_{out})` where
:math:`D_{out} = floor((D_{in} + 2 * padding[0] - kernel\_size[0]) / stride[0] + 1)`
:math:`H_{out} = floor((H_{in} + 2 * padding[1] - kernel\_size[1]) / stride[1] + 1)`
:math:`W_{out} = floor((W_{in} + 2 * padding[2] - kernel\_size[2]) / stride[2] + 1)`
Examples::
>>> # pool of square window of size=3, stride=2
>>> m = nn.AvgPool3d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.AvgPool3d((3, 2, 2), stride=(2, 1, 2))
>>> input = autograd.Variable(torch.randn(20, 16, 50,44, 31))
>>> output = m(input)
"""
def __init__(self, kernel_size, stride=None, padding=0, ceil_mode=False,
count_include_pad=True):
super(AvgPool3d, self).__init__()
self.kernel_size = kernel_size
self.stride = stride or kernel_size
self.padding = padding
self.ceil_mode = ceil_mode
self.count_include_pad = count_include_pad
def forward(self, input):
return F.avg_pool3d(input, self.kernel_size, self.stride,
self.padding, self.ceil_mode, self.count_include_pad)
def __setstate__(self, d):
super(AvgPool3d, self).__setstate__(d)
self.__dict__.setdefault('padding', 0)
self.__dict__.setdefault('ceil_mode', False)
self.__dict__.setdefault('count_include_pad', True)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'kernel_size=' + str(self.kernel_size) \
+ ', stride=' + str(self.stride) \
+ ', padding=' + str(self.padding) \
+ ', ceil_mode=' + str(self.ceil_mode) \
+ ', count_include_pad=' + str(self.count_include_pad) + ')'
[docs]class FractionalMaxPool2d(Module):
r"""Applies a 2D fractional max pooling over an input signal composed of several input planes.
Fractiona MaxPooling is described in detail in the paper `Fractional MaxPooling`_ by Ben Graham
The max-pooling operation is applied in kHxkW regions by a stochastic
step size determined by the target output size.
The number of output features is equal to the number of input planes.
Args:
kernel_size: the size of the window to take a max over.
Can be a single number k (for a square kernel of k x k) or a tuple (kh x kw)
output_size: the target output size of the image of the form oH x oW.
Can be a tuple (oH, oW) or a single number oH for a square image oH x oH
output_ratio: If one wants to have an output size as a ratio of the input size, this option can be given.
This has to be a number or tuple in the range (0, 1)
return_indices: if ``True``, will return the indices along with the outputs.
Useful to pass to nn.MaxUnpool2d. Default: ``False``
Examples:
>>> # pool of square window of size=3, and target output size 13x12
>>> m = nn.FractionalMaxPool2d(3, output_size=(13, 12))
>>> # pool of square window and target output size being half of input image size
>>> m = nn.FractionalMaxPool2d(3, output_ratio=(0.5, 0.5))
>>> input = autograd.Variable(torch.randn(20, 16, 50, 32))
>>> output = m(input)
.. _Fractional MaxPooling:
http://arxiv.org/abs/1412.6071
"""
def __init__(self, kernel_size, output_size=None, output_ratio=None,
return_indices=False, _random_samples=None):
super(FractionalMaxPool2d, self).__init__()
self.kh, self.kw = _pair(kernel_size)
self.return_indices = return_indices
self.register_buffer('_random_samples', _random_samples)
if output_size is not None:
self.outh, self.outw = _pair(output_size)
self.rh, self.rw = None, None
assert output_ratio is None
elif output_ratio is not None:
self.outh, self.outw = None, None
self.rh, self.rw = _pair(output_ratio)
assert output_size is None
assert 0 < self.rh < 1
assert 0 < self.rw < 1
else:
raise ValueError("FractionalMaxPool2d requires specifying either "
"an output size, or a pooling ratio")
def forward(self, input):
output_size, output_ratio = None, None
if self.outh is not None:
output_size = self.outh, self.outw
else:
output_ratio = self.rh, self.rw
ret = self._backend.FractionalMaxPool2d.apply(input, self.kw, self.kh, output_size, output_ratio,
self._random_samples)
return ret if self.return_indices else ret[0]
[docs]class LPPool2d(Module):
r"""Applies a 2D power-average pooling over an input signal composed of several input
planes.
On each window, the function computed is: :math:`f(X) = pow(sum(pow(X, p)), 1/p)`
- At p = infinity, one gets Max Pooling
- At p = 1, one gets Average Pooling
The parameters :attr:`kernel_size`, :attr:`stride` can either be:
- a single ``int`` -- in which case the same value is used for the height and width dimension
- a ``tuple`` of two ints -- in which case, the first `int` is used for the height dimension,
and the second `int` for the width dimension
Args:
kernel_size: the size of the window
stride: the stride of the window. Default value is :attr:`kernel_size`
ceil_mode: when True, will use `ceil` instead of `floor` to compute the output shape
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})`
- Output: :math:`(N, C, H_{out}, W_{out})` where
:math:`H_{out} = floor((H_{in} + 2 * padding[0] - dilation[0] * (kernel\_size[0] - 1) - 1) / stride[0] + 1)`
:math:`W_{out} = floor((W_{in} + 2 * padding[1] - dilation[1] * (kernel\_size[1] - 1) - 1) / stride[1] + 1)`
Examples::
>>> # power-2 pool of square window of size=3, stride=2
>>> m = nn.LPPool2d(2, 3, stride=2)
>>> # pool of non-square window of power 1.2
>>> m = nn.LPPool2d(1.2, (3, 2), stride=(2, 1))
>>> input = autograd.Variable(torch.randn(20, 16, 50, 32))
>>> output = m(input)
"""
def __init__(self, norm_type, kernel_size, stride=None, ceil_mode=False):
super(LPPool2d, self).__init__()
self.norm_type = norm_type
self.kernel_size = kernel_size
self.stride = stride
self.ceil_mode = ceil_mode
def forward(self, input):
return F.lp_pool2d(input, self.norm_type, self.kernel_size,
self.stride, self.ceil_mode)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ str(self.norm_type) + ', ' \
+ str(self.kernel_size) + ', ' \
+ 'stride=' + str(self.stride) + ', ' \
+ 'ceil_mode=' + str(self.ceil_mode) + ')'
class LPPool1d(Module):
r"""Applies a 1D power-average pooling over an input signal composed of several input
planes.
On each window, the function computed is: :math:`f(X) = pow(sum(pow(X, p)), 1/p)`
- At p = infinity, one gets Max Pooling
- At p = 1, one gets Average Pooling
Args:
kernel_size: a single int, the size of the window
stride: a single int, the stride of the window. Default value is :attr:`kernel_size`
ceil_mode: when True, will use `ceil` instead of `floor` to compute the output shape
Shape:
- Input: :math:`(N, C, L_{in})`
- Output: :math:`(N, C, L_{out})` where
:math:`L_{out} = floor((L_{in} + 2 * padding - kernel\_size) / stride + 1)`
Examples::
>>> # power-2 pool of window of length 3, with stride 2.
>>> m = nn.LPPool1d(2, 3, stride=2)
>>> input = autograd.Variable(torch.randn(20, 16, 50))
>>> output = m(input)
"""
def __init__(self, norm_type, kernel_size, stride=None, ceil_mode=False):
super(LPPool1d, self).__init__()
self.norm_type = norm_type
self.kernel_size = kernel_size
self.stride = stride
self.ceil_mode = ceil_mode
def forward(self, input):
return F.lp_pool1d(input, self.norm_type, self.kernel_size,
self.stride, self.ceil_mode)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ str(self.norm_type) + ', ' \
+ str(self.kernel_size) + ', ' \
+ 'stride=' + str(self.stride) + ', ' \
+ 'ceil_mode=' + str(self.ceil_mode) + ')'
[docs]class AdaptiveMaxPool1d(Module):
r"""Applies a 1D adaptive max pooling over an input signal composed of several input planes.
The output size is H, for any input size.
The number of output features is equal to the number of input planes.
Args:
output_size: the target output size H
return_indices: if ``True``, will return the indices along with the outputs.
Useful to pass to nn.MaxUnpool1d. Default: ``False``
Examples:
>>> # target output size of 5
>>> m = nn.AdaptiveMaxPool1d(5)
>>> input = autograd.Variable(torch.randn(1, 64, 8))
>>> output = m(input)
"""
def __init__(self, output_size, return_indices=False):
super(AdaptiveMaxPool1d, self).__init__()
self.output_size = output_size
self.return_indices = return_indices
def forward(self, input):
return F.adaptive_max_pool1d(input, self.output_size, self.return_indices)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'output_size=' + str(self.output_size) + ')'
[docs]class AdaptiveMaxPool2d(Module):
r"""Applies a 2D adaptive max pooling over an input signal composed of several input planes.
The output is of size H x W, for any input size.
The number of output features is equal to the number of input planes.
Args:
output_size: the target output size of the image of the form H x W.
Can be a tuple (H, W) or a single H for a square image H x H.
H and W can be either a ``int``, or ``None`` which means the size will
be the same as that of the input.
return_indices: if ``True``, will return the indices along with the outputs.
Useful to pass to nn.MaxUnpool2d. Default: ``False``
Examples:
>>> # target output size of 5x7
>>> m = nn.AdaptiveMaxPool2d((5,7))
>>> input = autograd.Variable(torch.randn(1, 64, 8, 9))
>>> output = m(input)
>>> # target output size of 7x7 (square)
>>> m = nn.AdaptiveMaxPool2d(7)
>>> input = autograd.Variable(torch.randn(1, 64, 10, 9))
>>> output = m(input)
>>> # target output size of 10x7
>>> m = nn.AdaptiveMaxPool2d((None, 7))
>>> input = autograd.Variable(torch.randn(1, 64, 10, 9))
>>> output = m(input)
"""
def __init__(self, output_size, return_indices=False):
super(AdaptiveMaxPool2d, self).__init__()
self.output_size = output_size
self.return_indices = return_indices
def forward(self, input):
return F.adaptive_max_pool2d(input, self.output_size, self.return_indices)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'output_size=' + str(self.output_size) + ')'
[docs]class AdaptiveMaxPool3d(Module):
r"""Applies a 3D adaptive max pooling over an input signal composed of several input planes.
The output is of size D x H x W, for any input size.
The number of output features is equal to the number of input planes.
Args:
output_size: the target output size of the image of the form D x H x W.
Can be a tuple (D, H, W) or a single D for a cube D x D x D.
D, H and W can be either a ``int``, or ``None`` which means the size will
be the same as that of the input.
return_indices: if ``True``, will return the indices along with the outputs.
Useful to pass to nn.MaxUnpool3d. Default: ``False``
Examples:
>>> # target output size of 5x7x9
>>> m = nn.AdaptiveMaxPool3d((5,7,9))
>>> input = autograd.Variable(torch.randn(1, 64, 8, 9, 10))
>>> output = m(input)
>>> # target output size of 7x7x7 (cube)
>>> m = nn.AdaptiveMaxPool3d(7)
>>> input = autograd.Variable(torch.randn(1, 64, 10, 9, 8))
>>> output = m(input)
>>> # target output size of 7x9x8
>>> m = nn.AdaptiveMaxPool3d((7, None, None))
>>> input = autograd.Variable(torch.randn(1, 64, 10, 9, 8))
>>> output = m(input)
"""
def __init__(self, output_size, return_indices=False):
super(AdaptiveMaxPool3d, self).__init__()
self.output_size = output_size
self.return_indices = return_indices
def forward(self, input):
return F.adaptive_max_pool3d(input, self.output_size, self.return_indices)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'output_size=' + str(self.output_size) + ')'
[docs]class AdaptiveAvgPool1d(Module):
r"""Applies a 1D adaptive average pooling over an input signal composed of several input planes.
The output size is H, for any input size.
The number of output features is equal to the number of input planes.
Args:
output_size: the target output size H
Examples:
>>> # target output size of 5
>>> m = nn.AdaptiveAvgPool1d(5)
>>> input = autograd.Variable(torch.randn(1, 64, 8))
>>> output = m(input)
"""
def __init__(self, output_size):
super(AdaptiveAvgPool1d, self).__init__()
self.output_size = output_size
def forward(self, input):
return F.adaptive_avg_pool1d(input, self.output_size)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'output_size=' + str(self.output_size) + ')'
[docs]class AdaptiveAvgPool2d(Module):
r"""Applies a 2D adaptive average pooling over an input signal composed of several input planes.
The output is of size H x W, for any input size.
The number of output features is equal to the number of input planes.
Args:
output_size: the target output size of the image of the form H x W.
Can be a tuple (H, W) or a single H for a square image H x H
H and W can be either a ``int``, or ``None`` which means the size will
be the same as that of the input.
Examples:
>>> # target output size of 5x7
>>> m = nn.AdaptiveAvgPool2d((5,7))
>>> input = autograd.Variable(torch.randn(1, 64, 8, 9))
>>> output = m(input)
>>> # target output size of 7x7 (square)
>>> m = nn.AdaptiveAvgPool2d(7)
>>> input = autograd.Variable(torch.randn(1, 64, 10, 9))
>>> output = m(input)
>>> # target output size of 10x7
>>> m = nn.AdaptiveMaxPool2d((None, 7))
>>> input = autograd.Variable(torch.randn(1, 64, 10, 9))
>>> output = m(input)
"""
def __init__(self, output_size):
super(AdaptiveAvgPool2d, self).__init__()
self.output_size = output_size
def forward(self, input):
return F.adaptive_avg_pool2d(input, self.output_size)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'output_size=' + str(self.output_size) + ')'
[docs]class AdaptiveAvgPool3d(Module):
r"""Applies a 3D adaptive average pooling over an input signal composed of several input planes.
The output is of size D x H x W, for any input size.
The number of output features is equal to the number of input planes.
Args:
output_size: the target output size of the form D x H x W.
Can be a tuple (D, H, W) or a single number D for a cube D x D x D
D, H and W can be either a ``int``, or ``None`` which means the size will
be the same as that of the input.
Examples:
>>> # target output size of 5x7x9
>>> m = nn.AdaptiveAvgPool3d((5,7,9))
>>> input = autograd.Variable(torch.randn(1, 64, 8, 9, 10))
>>> output = m(input)
>>> # target output size of 7x7x7 (cube)
>>> m = nn.AdaptiveAvgPool3d(7)
>>> input = autograd.Variable(torch.randn(1, 64, 10, 9, 8))
>>> output = m(input)
>>> # target output size of 7x9x8
>>> m = nn.AdaptiveMaxPool3d((7, None, None))
>>> input = autograd.Variable(torch.randn(1, 64, 10, 9, 8))
>>> output = m(input)
"""
def __init__(self, output_size):
super(AdaptiveAvgPool3d, self).__init__()
self.output_size = output_size
def forward(self, input):
return F.adaptive_avg_pool3d(input, self.output_size)
def __repr__(self):
return self.__class__.__name__ + '(' \
+ 'output_size=' + str(self.output_size) + ')'


Welcome to the greatest website you'll ever use!
Tired of constantly breaking out the calculator and opening seemingly endless links to find county, municipal, and school district millages?
Click the button below to stop pulling your hair out over minute details and get $?#@ done!