org.buildmlearn.practicehandwriting.activities
Classes
CharacterSelectionActivity
FreehandActivity
IncompleteActivity
LanguageActivity
MainMenuActivity
PracticeActivity
SplashActivity
TimeTrialActivity
TimeTrialResultActivity
TutorialActivity
WordSelectionActivity


Blockchain technology enables distributed public ledgers that hold immutable data in a secure and encrypted way and ensure that transactions can never be altered. - Internet Society
By allowing digital information to be distributed but not copied, blockchain technology created the backbone of a new type of internet. - Blockgeeks
Understand the Blockchain in Two Minutes:
“The blockchain is an incorruptible digital ledger of economic transactions that can be programmed to record not just financial transactions but virtually everything of value.” – Don & Alex Tapscott, authors Blockchain Revolution (2016).
More Information on Blockchain:
Here are some examples of how Autonomous Things are being used:
A look into the future with Autonomous Things:
Autonomous things, such as robots, drones and autonomous vehicles, use artificial intelligence (AI) to automate functions previously performed by humans.
“As autonomous things proliferate, we expect a shift from stand-alone intelligent things to a swarm of collaborative intelligent things, with multiple devices working together, either independently of people or with human input,” said Mr. Cearley.Here's more information on 'Autonomous Things' (robots):
An immersive experience is an illusory environment that completely surrounds you such that you feel that you are inside it and part of it. - Simplicable.com
The term is associated with technology environments that command the senses such as virtual reality and mixed reality. - Simplicable.com
In an immersive experience, the user accepts virtual elements of their environment as part of the whole, potentially becoming less conscious that those elements are not part of physical reality. - WhatIs.techtarget.com
Here's more Information on Immersive Experience:


The Web, or internet, is a global network of computers that connects billions of users worldwide. Invented in the 90s, the Web has grown to host over 30 billion pages. The vast majority of the Web is made up of inter-linked hypertext documents written in a language called Hypertext Markup Language, or HTML. When you visit a website (www.example.com) you're actually sending an HTTP request from your computer to a server who in turn finds the appropriate HTML document and sends it back to your computer where your web browser interprets and displays it. This video does a good job of explaining more.
HTML Hypertext Markup Language makes up most of the content on the web. HTML dictates Text Content, what you see, Markup,what it looks like behind the scenes References to other documents, images and videos Links to other pages in the form of hyperlinks.
Plain text equals plain text, markups do everything else.
This
video gives a good overview.
HTML is written in sentences or elements composed of tags and text. Tags are the markers that tell the text or source how to act or look.
This video explains the
distinction well.
There's a tag for anything you want to accomplish just a quick google search away. All tags fall into one of two categories based on how they interact with the page, inline or block.
We already know that HTML is the standard markup language used to create web pages. HTML provides the structure and the content for the pages we see on the web. It's its own language with syntax and rules. Each document or page is made up of lines of code called elements marked with tags explaining what it's supposed to do.
Think of a website as a house. Think about the structure, the wood beams holding it all up. Think about and layout of the house, where all the rooms are and how many bathrooms it has. Think about the wiring and plumbing. Thats HTML.
If HTML is the structure of the house, CSS is the style and decoration. Type of furniture, color of bedrooms, wall hangings, etc. CSS stands for Cascading Style Sheets and it's used for describing the look and formatting of a document written in a markup language. Uses it's own language and syntax to alter font size and color, background position, etc.
CSS gives programmers a way to control the style of related HTML elements. You can dictate commands like "make all class='concept-title' a certain color and size" and manage the look and style of your website.
The Developer Tools in Google Chrome give us great insight into how a page is structured and provides us not only with detailed information about how a web page is structured, styled, etc. but also empowers us with the ability to alter it. We can add/delete lines of code, adjust pixel ratios, colors, text, images. We can move the existing panes around. It turns any website into a sandbox.
To access Developer Tools: Google Chrome > Any website > Customization Tap (square with 3 bars in the top right-hand corner) > More Tools > Developer Tools
OR
Right Click any link or image > Inspect Element
HTML elements are either inline or block. Block elements form an "invisible box" around the content inside of them.
There are two things to remember right off the bat that will make evertything easier.
Rule #1: Every things is a box.Every element of a website is a box and often it's contained within another box. This is accomplished by putting elements inside of eachother in the code. Like you're placing your ships before a game of Battleship, you can place different elements around the page using the grid of pixels to arrange and line them up.
Rule #2: The structure of any website will resemble a big branch growing directly out away from the trunk of the tree. Every website is designed in a branching series of boxes that unfold like nesting dolls from biggest to smallest.
This video explains it perfectly.
The Document Object Model, more commonly known as DOM, is a cross platform and language independant convention for representing and interacting with objects in HTML and other markup languages. The nodes of every structure are organized in a tree-like structure called the DOM TREE Here's a great on breaking down a website and turning it into a DOM Tree.


WMT
You can view the WMT Machine Translation leaderboards:
Getting Started
You'll need the following in the root of your repository:
sotabench.py
file - contains benchmarking logic; the server will run this on each commitrequirements.txt
file - Python dependencies to be installed before runningsotabench.py
sotabench_setup.sh
(optional) - any advanced dependencies or setup, e.g. compilation
You can write whatever you want in your sotabench.py
file to get model predictions on the WMT datasets.
But you will need to record your results for the server, and you'll want to avoid doing things like downloading the dataset on the server. So you should:
- Include an Evaluation object in
sotabench.py
file to record the results. - Point to the server WMT data path - popular datasets are pre-downloaded on the server.
- Use Caching (optional) - to speed up evaluation by hashing the first batch of predictions.
We explain how to do these various steps below.
How Do I Initialize an Evaluator?
Before you start batching over the dataset and making predictions you need to create an evaluator instance to record results for a given leaderboard. For example, to evaluate on WMT2014 News English-French test set add this to your code:
from sotabencheval.machine_translation import WMTEvaluator, WMTDataset, Language evaluator = WMTEvaluator( dataset=WMTDataset.News2014, source_lang=Language.English, target_lang=Language.French, local_root='mydatasets', model_name='My Super Model' )
You can use evaluator.source_dataset_path: Path
and evaluator.target_dataset_path: Path
to get paths to the source and target SGML files.
In the example above the first one resolves to .data/nlp/wmt/newstest2014-fren-src.en.sgm
on
sotabench server and mydatasets/newstest2014-fren-src.en.sgm
when run locally.
If you want to use non-standard file names locally you can override the defaults like this:
evaluator = WMTEvaluator( ..., local_root='mydatasets' source_dataset_filename='english.sgm', target_dataset_filename='french.sgm' )
If you are reproducing a model from a paper, then you can enter the arXiv ID. If you put in the same model name string as on the leaderboard then you will enable direct comparison with the paper's model. For example:
evaluator = WMTEvaluator( dataset=WMTDataset.News2019, source_lang=Language.English, target_lang=Language.German, local_root="mydatasets", model_name="Facebook-FAIR (single)", paper_arxiv_id="1907.06616" )
The above will directly compare with the result of the paper when run on the server.
Instead of parsing the dataset files by yourself you can access raw segments as strings:
for segment_id, text in evaluator.source_segments: # translate text # or get segments within document context for document in evaluator.source_documents: context = [segment.text for segment in document.segments] for segment in document.segments: segment_id, text = segment.id, segment.text # translate text in context
How Do I Evaluate Predictions?
The evaluator object has an .add(answers: Dict[str, str])
method to submit predictions by batch or in full.
For WMT the expected input is a dictionary, where keys are source segments
ids and values are translated segments
(segment id is created by concatenating document id and the original segment id,
separted by #
.) For example:
evaluator.add({ 'bbc.381790#1': 'Waliser AMs sorgen sich um "Aussehen wie Muppets"', 'bbc.381790#2': 'Unter einigen AMs herrscht Bestürzung über einen...', 'bbc.381790#3': 'Sie ist aufgrund von Plänen entstanden, den Namen...' })
You can do this all at once in a single call to add()
, but more naturally, you will
probably loop over the dataset and call the method for the outputs of each batch.
That would look something like this (for a PyTorch example):
with torch.no_grad(): for i, (input, target) in enumerate(data_loader): ... output = model(input) # potentially formatting of the output here to be a dict evaluator.add(output)
When you are done, you can get the results locally by running:
evaluator.get_results()
But for the server you want to save the results by running:
evaluator.save()
This method serialises the results and model metadata and stores to the server database.
How Do I Cache Evaluation?
Sotabench reruns your script on every commit. This is good because it acts like continuous integration in checking for bugs and changes, but can be annoying if the model hasn't changed and evaluation is lengthy.
Fortunately sotabencheval has caching logic that you can use.
The idea is that after the first batch, we hash the model outputs and the current metrics and this tells us if the model is the same given the dataset. You can include hashing within an evaluation loop like follows (in the following example for a PyTorch repository):
with torch.no_grad(): for i, (input, target) in enumerate(data_loader): ... output = model(input) # potentially formatting of the output here to be a list of dicts evaluator.add(output) if evaluator.cache_exists: break evaluator.save()
If the hash is the same as in the server, we infer that the model hasn't changed, so we simply return hashed results rather than running the whole evaluation again.
Caching is very useful if you have large models, or a repository that is evaluating multiple models, as it speeds up evaluation significantly.
A Full sotabench.py Example
Below we show an implementation for a model from the torchhub repository. This incorporates all the features explained above: (a) using the WMT Evaluator, (b) accessing segments from evaluator, and (c) the evaluation caching logic. For clarity we omit batching and simply translate segment by segment.
from sotabencheval.machine_translation import WMTEvaluator, WMTDataset, Language from tqdm import tqdm import torch evaluator = WMTEvaluator( dataset=WMTDataset.News2019, source_lang=Language.English, target_lang=Language.German, local_root="data/nlp/wmt", model_name="Facebook-FAIR (single)", paper_arxiv_id="1907.06616" ) model = torch.hub.load('pytorch/fairseq', 'transformer.wmt19.en-de.single_model', force_reload=True, tokenizer='moses', bpe='fastbpe').cuda() for sid, text in tqdm(evaluator.metrics.source_segments.items()): translated = model.translate(text) evaluator.add({sid: translated}) if evaluator.cache_exists: break evaluator.save() print(evaluator.results)
Need More Help?
Head on over to the Natural Language Processing section of the sotabench forums if you have any questions or difficulties.


Picture This:
You're a small business owner with a great idea for a new clothing brand. You spend many long nights and countless dollars designing and fabricating your
awesome new products in your garage or basement. You buy a nice shop in a good location to setup your business.  Your hard work will soon be rewarded. It is at this moment you remember: it's 2021 and there's a lockdown. No one can come to your store. What do you do
now? You already used your child's college fund during the setup process, so you can't afford a software developer.
Look no further. With our Mobile Clothing App Framework®, the luxury of a personalized app is within reach. Our framework cuts out the need for the middleman, you can setup your
shop without the need of a software developer (they're overpaid anyways). With our easy to use app, all you need to do is add any items you are trying to sell and boom, they will
now be visible and available for purchase to the 2.7 billion people that own smartphones (or just to the people who download your app, whichever is lower).
After setup, our app will allow customers to browse your entire stock and purchase items using Square's In App Payment system. Any customer who places an order will be required
to enter all the information necessary to ship their products. It really is as easy as that. You enter your stock, the app does the rest. Over 100 satisfied customers* can't be
wrong, Try our framework today!
*(Satisfied customers may or may not be customers of our product)


SHAKESPEARE IN LOVE (1998)
A Film Review by Ted Prigge
Copyright 1999 Ted Prigge
Director: John Madden
Writers: Marc Norman and Tom Stoppard
Starring: Joseph Fiennes, Gwyneth Paltrow, Geoffrey Rush, Colin Firth, Ben Affleck, Judi Dench, Tom Wilkinson, Simon Callow, Imelda Staunton, Rupert Everett
It's been awhile since we've had a truly great rethinking of the works of an artist known primarily for uniting and then splitting up a woman named Juliet and a man named Romeo...about three years, if I'm correct (that would point out that I am referring to none other than "Richard III," Richard Loncraine and Ian McKellen's wonderfully naughty adaptation-cum-daring-melodrama). But it's been, oh, three decades at least since we've had the last real retooling of the master's work ("Richard III" more or less played the narrative straight through), and that's not counting the mediocre film version - of course, I'm referring to "Rosencrantz and Guildenstern are Dead," the legendary piece of wit from Tom Stoppard that is almost as cheerfully absurdist as, oh, "Waiting for Godot." Apparently he didn't get enough from that play, and needed to show us once again exactly how much he knows about the man and his subsequent work.
That being, "Shakespeare in Love," the egg that has since hatched from his mammoth-sized cranium, as well as that of Marc Norman (who came up with the actual plot), is no "RAGAD," but hey how the hell could it be. It's lighter. More cheerful. More accessible. Only slightly less engaging.  In fact, in a year when even the biggest blockbusters can't lift you off your seat and put a big fat grimace across your face, it's refreshing to see a movie so witty and wonderfully passionate as this, and surprising to find that even if you can't name more than two of his plays ("Romeo and Juliet" and "Hamlet" notwithstanding), you can still find that this love-story-cum-backstage-pass-cum-witty-rethinking-of-the-life-of-a-certa in-playwright-cum-costume-drama-cum-flat-out-comedy to be almost as pleasing as I or anyone else who actually enjoys the Bard does (not that I'm being priggish about it). Because Stoppard, even in "RAGAD," doesn't merely show off his knowledge of the Bard's work, but demonstrates it as well, and forms his plays/scripts so that even if you're not sure of the source material, you can still follow along fine (although it doesn't hurt to know what he's talking about, just to get some more of the jokes).
And he makes sure that the characters it's about are not just recreations from a previous much better play, but actual fresh realizations so the story is not stale and so it's easy to be drawn in. After all, Rosencrantz and Guildenstern, presented so briefly in the play, were reintroduced by Stoppard as a variation on the Laurel and Hardy mold, a feuding pair of friends who aren't only likable and sympathetic because their fate is so obvious, but also because they're such great characters. Stoppard does a similar thing with the way he recreates Shakespeare. Thought of mostly as a prissy, maybe even pretentious artist, the way Shakespeare is presented here is a wonderful example of wit: thin, even (as I've been told) devastatingly attractive, and, best of all, a hack, he speaks in a whirlwind of aphorisms and metaphors, just trying to get his emotions out (a friend, after a short speech he's given, says "Enough of that; talk prose."). When we first meet him, he's a local London playwright, estranged from his wife, selling mere ideas to theatre-owners in hopes of advances and money per page he writes, constantly living under the glow of a certain other playwright, the then-more notable Christopher Marlow (Rupert Everett, a wonderful in-joke here, eh?). Under the employment of Philip Henslowe (Geoffrey Rush, in full over-the-top mode here, with a funny mustache and a medium-pitched, hilarious speaking voice that screams "rat"), he is currently laboring over this new play, aptly-titled "Romeo and Ethel, the Pirate's Daughter").
Everything explodes when, during a rehearsal, an actor reads from a play of his (the film finds him after early successes, like "Titus Andronicus," and before his later masterpieces, like, oh, "Hamlet"), and does it with such passion and gusto that he must get his name.  The two meet again, her no longer in disguise, at a dance, and hit it off immeadiately. Once Viola has been cast as Romeo and has revealed her true identity to Shakespeare, the two launch into a series of passionate love scenes, and she quickly becomes his darling muse. As they make love, with the aid of her fellow nurse (Imelda Staunton), his banal play (written to make sure that it has pirates and a dog, as Henslowe points out) turns into the greatest love story of all time, and just as those two were lovers without any hope of a good finale, these two take delight in the fact that their relationship as well is doomed from the get-go, that she will eventually have to reclaim her social position, and he his, but in the meantime, they carry on such a passionate affair that it sparkles all the energy in him to write one of his first great plays, at least the one that will get him better jobs in the future.
But there's more to the film than just making light of Shakespeare's early career and his background for writing such passionate plays: the film is basically your traditional Shakespearean play, or at least a great carbon copy of such. It has true love, villainy, unexpected deaths, vicious twists, character manipulation, bawdy humor, social commentary, inside jokes about the times and even itself, and, the most classic Shakespearean entity: crossdressing, and not just great crossdressing, convincing crossdressing, where people actually buy that the gender is what it seems to be. It even has hilarious connections to the final form of "Romeo and Juliet" (imagine, if you will, a balcony scene culminating in a great fall and a chase by dogs). And it's all done in a witty, hilarious way that may have passed as mid-level Shakespeare, because Stoppard and Norman know exactly what they're doing (and so, I guess, does the other writer, Marc Norman). He knows what's funny, and what is also appealing. He crafts not only great lead characters, but also memorable supporting characters, like that of Hugh Fennyman (Tom Wilkinson), the local moneylender, first seen buring the feet of Henslowe, who owes him money, and later seen cherishing the fact that he has a role in the final production of the play (even if it is as the apothecry). His delight in playing the role is such a sweetly funny thing to behold that it gives the film another layer of joy.
But there's much more. I just basically loved almost everything in this movie. I loved how it knew its subject backwards and forwards and knew how to present it in a witty and entertaining way (it even drolly gives a brief nod to Will Kemp, one of the more famous Elizabethan actors). I loved how the play was constructed and made so that Shakespeare could easily move from a forgettable work to an unforgettable one. I loved all the performances, especially Joseph Fiennes, so forgettable in "Elizabeth," and here so hilariously witty and charming; and even especially Judi Dench, playing an older, more knowledgable Queen Elizabeth, who steals all the three scenes she's in (an aside to Viola's fiance is just fantastic). For the first time, Gwyneth Paltrow measures up to her claim to fame (read: I finally respect her).
But most of all, I loved how the center relationship is so full of life and vitality that we don't for one second doubt it's sincerity (a friend of mine did point out that when one is in love, one doesn't feel like doing work - not so: famous composer Leos Janacek was noted as doing the best work of his entire life when conducting a passionate affair, with a woman who happened to be half his age...and if it works for him, it could've worked for Shakespeare). And we feel for them so that even though we know that it's a cursed one from the beginning (like the way we know that Rosencrantz and Guildenstern are going to die at the end of either of the plays they're in), we can't help but feel a huge loss when it actually comes around. It's magnificent direction (by John Madden) and beautiful look (which looks genuinely Elizabethan) only help to add to the overall impact of the film, but by the end, this is just another story of a man who appears to be great but is actually as hopeless lost and hopelessly romantic as the rest of us. Like us all, we see the great Shakespeare as a local hack, trying to find the muse that will pull him out of his prison, and when this happens, it's like a beautiful awakening. So is the film. Who else could have possibly made even the lowest artist feel better about themselves by downgrading Shakespeare and not succumb to the wrath of purists everywhere than Tom Stoppard? Just a great man, even if his one attempt at directing was a little weak. Norman too.
MY RATING (out of 4): ***1/2
Homepage at: http://www.geocities.com/Hollywood/Hills/8335/
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


Fixed Effects Models
Fixed Effects (FE) models are a terribly named approach to dealing with clustered data, but in the simplest case, serve as a contrast to the random effects (RE) approach in which there are only random intercepts5. Despite the nomenclature, there is mainly one key difference between these models and the ‘mixed’ models we discuss. Both allow a (random) cluster-specific effect to be added to model, but the FE approach allows that effect to correlate with the predictors, while the RE does not (by default). In practice however, this means that they may end up being quite different conceptual models as well. As with cluster robust standard errors, economists, and again those trained in that fashion, have historically preferred these models. In my experience they are rarely used in other disciplines.
First, let us understand this cluster-specific effect. In the standard regression setting we have a basic intercept, while here, each cluster will provide a nudge above or below that overall effect. Consider the following model (ignoring treatment for now):
\[ y = \textrm{Int} + \textrm{ClusterEffect} + b*\mathrm{time} + \epsilon \]
The cluster effect is different from one cluster to the next, but constant for a given cluster. One way we could perform such a model is just to include id
as a predictor, thereby getting a unique estimate for each cluster added to the model. In other words, we can also see the situation as if one had simply created a dummy variable for id
and conducted a standard linear model. This is in fact how one can think of the FE model, though where the cluster-specific effects are assumed constants to be estimated, and in the past these models were sometimes referred to as least squares dummy variable (LSDV) regression models6. If you actually run the LSDV model, the statistical results for time will be identical.
Why would we be worried about the potential correlation between the cluster-specific effects and the model covariates? In typical social science and economic data it’s probably likely that unspecified cluster level effects might have some correlation with the individual level covariates. This leads to inconsistent estimates in the RE approach, and as such the FE might be used instead.
In the following we use the plm package to estimate the FE model. I highly recommend reading the excellent vignette for this package if you are one of those econometrically trained folk new to R or the mixed model approach, or conversely, other folk wishing to understand the econometric perspective.
FE_mod = plm(y ~ as.numeric(time) + treatment, data=d, index='id', model='within')
summary(FE_mod)
Oneway (individual) effect Within Model
Call:
plm(formula = y ~ as.numeric(time) + treatment, data = d, model = "within",
index = "id")
Balanced Panel: n=2500, T=4, N=10000
Residuals :
Min. 1st Qu. Median 3rd Qu. Max.
-2.66000 -0.40500 0.00265 0.40000 2.56000
Coefficients :
Estimate Std. Error t-value Pr(>|t|)
as.numeric(time) 0.5085588 0.0064962 78.285 < 2.2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Total Sum of Squares: 7188.7
Residual Sum of Squares: 3955.8
R-Squared: 0.44972
Adj. R-Squared: 0.33725
F-statistic: 6128.62 on 1 and 7499 DF, p-value: < 2.22e-16
Note how there is no intercept or treatment effect. In this circumstance of a random intercept model, the FE model can also be seen as a ‘demeaning’ approach, were the model within a cluster is:
\[y_i-\bar{y_i} = (X_i-\bar{X_i})\beta + (\epsilon-\bar{\epsilon_i})\]
In other words, we subtract the mean from each covariate and response and run the model that way (this is also known as the within transformation). Note the following produces the same result, although the standard error for time is off7.
d %>%
group_by(id) %>%
mutate(ybar = y-mean(y),
timebar = time-mean(time)) %$%
lm(ybar ~ timebar) %>%
summary
Call:
lm(formula = ybar ~ timebar)
Residuals:
Min 1Q Median 3Q Max
-2.66127 -0.40475 0.00265 0.40017 2.56068
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 5.741e-19 6.290e-03 0.00 1
timebar 5.086e-01 5.626e-03 90.39 <2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 0.629 on 9998 degrees of freedom
Multiple R-squared: 0.4497, Adjusted R-squared: 0.4497
F-statistic: 8171 on 1 and 9998 DF, p-value: < 2.2e-16
Because of this, if something is constant within a cluster, it drops out of the model, and this includes anything that has only one observation even if the covariate is normally time-varying. So, not only do you lose the ability to model cluster level effects, though these are ‘controlled for’, you also lose data. In this we lose the treatment effect entirely, which would be completely unacceptable in most circumstances8.
There seem to be philosophical reasons why some prefer FE models that go beyond the practical, because I don’t understand the often rigid preference by some adherents over RE models given the drawbacks. I personally have never come across a valid justification for not investigating cluster level covariates if they are available (i.e. almost always in social science, educational, economic, epidemiological and other data, and often would simply include cluster-level averages of available variables). In addition, few of the applications of FE models actually seem interested in the cluster-specific effects, in short treating the clustering as a nuisance, much like the cluster-robust standard error approach9.
Pros
- Does not assume X and random effects are uncorrelated.
Cons
- Ignores cluster level covariates or anything cluster constant (i.e. will almost always lose data).
- Doesn’t easily extend to more complex clustering structures.
- Less efficient that RE if RE assumption holds
- Technically one can do random slopes also (mentioned in passing in Greene), but nothing out there does.
- Awkward (my opinion) extension to GLM setting for binary and counts
- More will be pointed out with the mixed models
Gist: If your goal is statistical consistency above all other considerations, this approach is for you. However, given that with mixed models we can potentially overcome the primary issue that the FE model addresses (RE correlated with covariates10), this seems a difficult modeling approach to justify.
Actually, FE models extend beyond this but I’ve never seen the treatment in textbook presentations, nor am familiar with tools that do so aside from the latent variable approach.↩
This Stata note highlights the distinction.↩
This is due to the fact that estimation of the group means was not taken into account.↩
Note that you could still get the interaction of time x treatment, which you’d definitely want to examine in the experimental longitudinal setting. In other circumstances and with numerous covariates, this may become unwieldy, and then there are the issues of when the interaction is not significant, you have no main effect to fall back on, and you’re also testing an interaction without all the component main effects.↩
Still applies here, i.e. we can still use cluster robust standard errors.↩
One can use aggregated values of the potentially offending covariates as cluster level covariates. For example, if we had people clustered within political district, we could use average income as a district-level covariate. Such models are sometimes referred to as hybrids, incorporating both the FE and RE approaches, but this is unwarranted. All three are simply random effects models of different kinds.↩


#include <sysc/tracing/sc_vcd_trace.h>
Public Types | |
| enum | vcd_enum { VCD_WIRE = 0, VCD_REAL, VCD_EVENT, VCD_TIME, VCD_LAST } |
Public Member Functions | |
| vcd_trace_file (const char *name) | |
| ~vcd_trace_file () | |
| std::string | obtain_name () |
Public Attributes | |
| std::vector< vcd_trace * > | traces |
Protected Member Functions | |
| virtual void | trace (const sc_time &object, const std::string &name) |
| virtual void | trace (const sc_event &object, const std::string &name) |
| void | trace (const bool &object, const std::string &name) |
| virtual void | trace (const sc_dt::sc_bit &object, const std::string &name) |
| void | trace (const sc_dt::sc_logic &object, const std::string &name) |
| void | trace (const unsigned char &object, const std::string &name, int width) |
| void | trace (const unsigned short &object, const std::string &name, int width) |
| void | trace (const unsigned int &object, const std::string &name, int width) |
| void | trace (const unsigned long &object, const std::string &name, int width) |
| void | trace (const char &object, const std::string &name, int width) |
| void | trace (const short &object, const std::string &name, int width) |
| void | trace (const int &object, const std::string &name, int width) |
| void | trace (const long &object, const std::string &name, int width) |
| void | trace (const sc_dt::int64 &object, const std::string &name, int width) |
| void | trace (const sc_dt::uint64 &object, const std::string &name, int width) |
| void | trace (const float &object, const std::string &name) |
| void | trace (const double &object, const std::string &name) |
| void | trace (const sc_dt::sc_uint_base &object, const std::string &name) |
| void | trace (const sc_dt::sc_int_base &object, const std::string &name) |
| void | trace (const sc_dt::sc_unsigned &object, const std::string &name) |
| void | trace (const sc_dt::sc_signed &object, const std::string &name) |
| void | trace (const sc_dt::sc_fxval &object, const std::string &name) |
| void | trace (const sc_dt::sc_fxval_fast &object, const std::string &name) |
| void | trace (const sc_dt::sc_fxnum &object, const std::string &name) |
| void | trace (const sc_dt::sc_fxnum_fast &object, const std::string &name) |
| template<class T > | |
| void | traceT (const T &object, const std::string &name, vcd_enum type=VCD_WIRE) |
| virtual void | trace (const sc_dt::sc_bv_base &object, const std::string &name) |
| virtual void | trace (const sc_dt::sc_lv_base &object, const std::string &name) |
| void | trace (const unsigned &object, const std::string &name, const char **enum_literals) |
| void | write_comment (const std::string &comment) |
| void | cycle (bool delta_cycle) |
Definition at line 68 of file sc_vcd_trace.h.
Definition at line 73 of file sc_vcd_trace.h.
| sc_core::vcd_trace_file::vcd_trace_file | ( | const char * | name | ) |
| sc_core::vcd_trace_file::~vcd_trace_file | ( | ) |
| void sc_core::vcd_trace_file::cycle | ( | bool | delta_cycle | ) | [protected, virtual] |
Implements sc_core::sc_trace_file.
| std::string sc_core::vcd_trace_file::obtain_name | ( | ) |
| void sc_core::vcd_trace_file::trace | ( | const unsigned & | object, | |
| const std::string & | name, | |||
| const char ** | enum_literals | |||
| ) | [protected] |
| virtual void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_lv_base & | object, | |
| const std::string & | name | |||
| ) | [protected, virtual] |
| virtual void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_bv_base & | object, | |
| const std::string & | name | |||
| ) | [protected, virtual] |
| void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_fxnum_fast & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_fxnum & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_fxval_fast & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_fxval & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_signed & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_unsigned & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_int_base & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_uint_base & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const double & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const float & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const sc_dt::uint64 & | object, | |
| const std::string & | name, | |||
| int | width | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const sc_dt::int64 & | object, | |
| const std::string & | name, | |||
| int | width | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const long & | object, | |
| const std::string & | name, | |||
| int | width | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const int & | object, | |
| const std::string & | name, | |||
| int | width | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const short & | object, | |
| const std::string & | name, | |||
| int | width | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const char & | object, | |
| const std::string & | name, | |||
| int | width | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const unsigned long & | object, | |
| const std::string & | name, | |||
| int | width | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const unsigned int & | object, | |
| const std::string & | name, | |||
| int | width | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const unsigned short & | object, | |
| const std::string & | name, | |||
| int | width | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const unsigned char & | object, | |
| const std::string & | name, | |||
| int | width | |||
| ) | [protected] |
| void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_logic & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| virtual void sc_core::vcd_trace_file::trace | ( | const sc_dt::sc_bit & | object, | |
| const std::string & | name | |||
| ) | [protected, virtual] |
| void sc_core::vcd_trace_file::trace | ( | const bool & | object, | |
| const std::string & | name | |||
| ) | [protected] |
| virtual void sc_core::vcd_trace_file::trace | ( | const sc_event & | object, | |
| const std::string & | name | |||
| ) | [protected, virtual] |
| virtual void sc_core::vcd_trace_file::trace | ( | const sc_time & | object, | |
| const std::string & | name | |||
| ) | [protected, virtual] |
| void sc_core::vcd_trace_file::traceT | ( | const T & | object, | |
| const std::string & | name, | |||
| vcd_enum | type = VCD_WIRE | |||
| ) | [inline, protected] |
Definition at line 179 of file sc_vcd_trace.h.
| void sc_core::vcd_trace_file::write_comment | ( | const std::string & | comment | ) | [protected, virtual] |
Implements sc_core::sc_trace_file.
| std::vector<vcd_trace*> sc_core::vcd_trace_file::traces |
Definition at line 232 of file sc_vcd_trace.h.


Active Ingredient
Polyethylene Glycol 3350, 17 g (cap filled to line)
Purpose
Osmotic Laxative
Use
- relieves occasional constipation (irregularity)
- generally produces a bowel movement in 1 to 3 days
Warnings
Allergy alert: Do not use if you are allergic to polyethylene glycol
Do not use if you have kidney disease, except under the advice and supervision of a doctor
Ask a doctor before use if you have
- nausea, vomiting or abdominal pain
- a sudden change in bowel habits that lasts over 2 weeks
- irritable bowel syndrome
Ask a doctor or pharmacist before use if you are taking a prescription drug
When using this product you may have loose, watery, more frequent stools
Stop use and ask a doctor if
- you have rectal bleeding or your nausea, bloating, cramping or abdominal pain gets worse. These may be signs of a serious condition.
- you get diarrhea
- you need to use a laxative for longer than 1 week
If pregnant or breast-feeding, ask a health professional before use.
Keep out of the reach of children
In case of overdose, get medical help or contact a POISON CONTROL CENTER right away. (1-800-222-1222)
Directions
- do not take more than directed unless advised by your doctor
- the bottle top is a measuring cap marked to contain 17 grams of powder when filled to the indicated line.
- adults and children 17 years of age and older:
- fill to top of line in cap which is marked to indicate the correct dose (17 g)
- stir and dissolve in any 4 to 8 ounces of beverage (cold, hot or room temperature) then drink
- use once a day
- use no more than 7 days
- children 16 years of age or under: ask a doctor
Other Information
- store at 20°- 25°C (68°– 77°F)
- tamper-evident: do not use if printed foil seal under cap is missing, open or broken
Questions or comments?
1-866-403-7592
PACKAGE LABEL.PRINCIPAL DISPLAY PANEL
NDC 43386-312-08
Original Prescription Strength
GaviLax
Polyethylene Glycol 3350
Powder for Solution, Osmotic Laxative
14 ONCE-DAILY DOSES
NET WT 8.3 OZ (238 g)


Cake Category
Make-Up Studio Category
Who We Are
Our Feature and Performance
Quality
Our first priority is in the quality we we never compromised and assured you that we wil always offer you that all the time.
Creativity
We have creative chefs, so every product is craetive and our cakes are so beautiful because of our chef are awesomely creative.
Experience
We are experienced chefs and make-up artist, we offer standard products and service, we also trained of staffs with all level of professionalism.
Delivery
We humbly take out time to deliver within and outside the state and we make sure to deliver on time.


Home
More
Maps
Users's Places of Origin
You must be logged in to permanently save your marker on the map.
Past Olympic Cities


You can create a New Scheduled Test by any of the following methods
1) From Log entries
a) Double Click any Log entry to open the Scheduled Test Wizard
Note: this is a good way to create a scheduled test because it then loads the Wizard with the correct API function selected.
2) From the Context menu.
a) Click the New Scheduled Test Button
3) From the Menu
a) Click Application > Create a Scheduled Test
4) From the Project Pane
a) Right click the Tests Node under the Application for which you would like to create a test.
b) Select Create a new Test.
Note: if you create a test in per-thread mode you can create a test for a single thread. If you are in per-thread mode and create a test from the main log window the test will apply to all threads; conversely, if you are in per-thread mode and you create a test in one of the thread specific API logs the test will apply only to that thread.
Deleting a test
To delete a test, find the test in the project pane, right click and select Delete test.
You can also delete a test by right clicking the test in the tests pane and selecting Delete test.


Source
Provides a macro to inspect source code rather than execute it
Summary↑
| code(src) | This macro does not execute the code that is passed in, rather it returns the source so that it can be shown in the presentation |
Macros
This macro does not execute the code that is passed in, rather it returns the source so that it can be shown in the presentation.


The Select
With initial value reactive form
With initial value ngModel
{{c.name}}
Disabled, synced with previous
{{c.name}}
Undefined value with placeholder
{{c.name}}
Undefined value without placeholder
{{c.name}}
Multiple with initial value
{{c.name}}
Multiple, disabled, synced with previous
{{c.name}}
Multiple without initial value
{{c.name}}


<bookrestriction>
The <bookrestriction>
element indicates whether the book is classified
or restricted in some way. The @value
attribute indicates any restrictions on
the use of the material, such as declaring the information confidential or for licensed use
only.
Category: Bookmap metadata elements


Introduction¶
Nifty, for now, uses Python 2.7. Please keep this in mind.
Running from the Command Line¶
Nifty is started with the runNifty command by specifying a pipeline or step with arguments and options.
The syntax used to start Nifty is:
runNifty <Pipeline or Step Name> <arguments>
To get help or list the available options, type the runNifty command without any arguments.
runNifty
Running from Python¶
Python Programmers: even though Nifty’s API has not been defined yet, you can still run Nifty Pipelines, Steps, Routines and Tasks from a Python interpeter by importing them.
For example, to run a final cube merge from the Python interpreter:
# Import relevant modules; you can find those at top of nifsMerge.py
from pyraf import iraf, iraffunctions
# Import relevant local script
import nifty.pipeline.steps.nifsMerge
# Set up iraf
iraf.gemini()
iraf.gemtools()
iraf.gnirs()
iraf.nifs()
# Define routine parameters
scienceDirectoryList = []
cubeType = "uncorrected"
mergeType = "sum"
use_pq_offsets = True
im3dtran = True
over = False
# Start the cube merging
nifty.pipeline.steps.nifsMerge.mergeCubes(scienceDirectoryList, cubeType, mergeType, use_pq_offsets, im3dtran, over="")
You might be able to figure out what imports you need by checking the tops of the relevant scripts.
Examples of Running from the Command Line¶
Starting a Data Reduction from the Beginning
Supply the -i flag to start the NIFS pipeline, populating a configuration file interactively:
runNifty nifsPipeline -i
Supply a config.cfg file to start the NIFS pipeline from a pre-built configuration file:
runNifty nifsPipeline config.cfg
Supply the -f flat to do a fully automatic data reduction, downloading raw data from the Gemini Public Archive (Eg: GN-2013A-Q-62):
runNifty nifsPipeline -f GN-2013A-Q-62
Supply the -f flag to do a fully automatic data reduction, using raw data from a local directory (Eg: /Users/ncomeau/data/TUTORIAL):
runNifty nifsPipeline -f /Users/ncomeau/data/TUTORIAL
Starting a Data Reduction from a Specified Point
You can run each step, one at a time, from the command line like so. You need a config.cfg file in your current working directory to run individual steps. Each step requires the general config section and its unique config section to be populated.
You can also run an individual step by turning them on or off in nifsPipeline config and running the nifsPipeline.
nifsSort: To only copy and sort NIFS raw data use a config.cfg file like this:
# Nifty configuration file.
#
# Each section lists parameters required by a pipeline step.
manualMode = False
over = False
extractionXC = 15.0
extractionYC = 33.0
extractionRadius = 2.5
scienceOneDExtraction = True
scienceDirectoryList = []
telluricDirectoryList = []
calibrationDirectoryList = []
[nifsPipelineConfig]
sort = True
calibrationReduction = False
telluricReduction = False
scienceReduction = False
telluricCorrection = False
fluxCalibration = False
merge = False
telluricCorrectionMethod = 'gnirs'
fluxCalibrationMethod = 'gnirs'
mergeMethod = ''
[sortConfig]
rawPath = '/Users/nat/data/TUTORIAL'
program = ''
proprietaryCookie = ''
skyThreshold = 2.0
sortTellurics = True
telluricTimeThreshold = 5400
[calibrationReductionConfig]
baselineCalibrationStart = 1
baselineCalibrationStop = 4
[telluricReductionConfig]
telStart = 1
telStop = 5
telluricSkySubtraction = True
[telluricCorrectionConfig]
telluricCorrectionStart = 1
telluricCorrectionStop = 9
hLineMethod = 'vega'
hLineInter = False
continuumInter = False
telluricInter = False
tempInter = False
standardStarSpecTemperature = ''
standardStarMagnitude = ''
standardStarRA = ''
standardStarDec = ''
standardStarBand = ''
[fluxCalbrationConfig]
fluxCalibrationStart = 1
fluxCalibrationStop = 6
[mergeConfig]
mergeStart = 1
mergeStop = 3
mergeType = 'median'
use_pq_offsets = True
im3dtran = True
# Good luck with your Science!
And run the nifsPipeline with:
runNifty nifsPipeline config.cfg
nifsBaselineCalibration: To only reduce calibrations use a config.cfg file like this:
# Nifty configuration file.
#
# Each section lists parameters required by a pipeline step.
manualMode = False
over = False
extractionXC = 15.0
extractionYC = 33.0
extractionRadius = 2.5
scienceOneDExtraction = True
scienceDirectoryList = []
telluricDirectoryList = []
calibrationDirectoryList = []
[nifsPipelineConfig]
sort = False
calibrationReduction = True
telluricReduction = False
scienceReduction = False
telluricCorrection = False
fluxCalibration = False
merge = False
telluricCorrectionMethod = 'gnirs'
fluxCalibrationMethod = 'gnirs'
mergeMethod = ''
[sortConfig]
rawPath = '/Users/nat/data/TUTORIAL'
program = ''
proprietaryCookie = ''
skyThreshold = 2.0
sortTellurics = True
telluricTimeThreshold = 5400
[calibrationReductionConfig]
baselineCalibrationStart = 1
baselineCalibrationStop = 4
[telluricReductionConfig]
telStart = 1
telStop = 5
telluricSkySubtraction = True
[telluricCorrectionConfig]
telluricCorrectionStart = 1
telluricCorrectionStop = 9
hLineMethod = 'vega'
hLineInter = False
continuumInter = False
telluricInter = False
tempInter = False
standardStarSpecTemperature = ''
standardStarMagnitude = ''
standardStarRA = ''
standardStarDec = ''
standardStarBand = ''
[fluxCalbrationConfig]
fluxCalibrationStart = 1
fluxCalibrationStop = 6
[mergeConfig]
mergeStart = 1
mergeStop = 3
mergeType = 'median'
use_pq_offsets = True
im3dtran = True
# Good luck with your Science!
And run the nifsPipeline with:
runNifty nifsPipeline config.cfg
nifsReduce Telluric: To only reduce telluric data use a config.cfg file like this: Make sure to populate scienceDirectoryList, telluricDirectoryList and calibrationDirectoryList before running!
# Nifty configuration file.
#
# Each section lists parameters required by a pipeline step.
manualMode = False
over = False
extractionXC = 15.0
extractionYC = 33.0
extractionRadius = 2.5
scienceOneDExtraction = True
scienceDirectoryList = []
telluricDirectoryList = []
calibrationDirectoryList = []
[nifsPipelineConfig]
sort = False
calibrationReduction = False
telluricReduction = True
scienceReduction = False
telluricCorrection = False
fluxCalibration = False
merge = False
telluricCorrectionMethod = 'gnirs'
fluxCalibrationMethod = 'gnirs'
mergeMethod = ''
[sortConfig]
rawPath = '/Users/nat/data/TUTORIAL'
program = ''
proprietaryCookie = ''
skyThreshold = 2.0
sortTellurics = True
telluricTimeThreshold = 5400
[calibrationReductionConfig]
baselineCalibrationStart = 1
baselineCalibrationStop = 4
[telluricReductionConfig]
telStart = 1
telStop = 5
telluricSkySubtraction = True
[telluricCorrectionConfig]
telluricCorrectionStart = 1
telluricCorrectionStop = 9
hLineMethod = 'vega'
hLineInter = False
continuumInter = False
telluricInter = False
tempInter = False
standardStarSpecTemperature = ''
standardStarMagnitude = ''
standardStarRA = ''
standardStarDec = ''
standardStarBand = ''
[fluxCalbrationConfig]
fluxCalibrationStart = 1
fluxCalibrationStop = 6
[mergeConfig]
mergeStart = 1
mergeStop = 3
mergeType = 'median'
use_pq_offsets = True
im3dtran = True
# Good luck with your Science!
And run the nifsPipeline with:
runNifty nifsPipeline config.cfg
nifsReduce Science: To only reduce science data use a config.cfg file like this: Make sure to populate scienceDirectoryList, telluricDirectoryList and calibrationDirectoryList before running!
# Nifty configuration file.
#
# Each section lists parameters required by a pipeline step.
manualMode = False
over = False
extractionXC = 15.0
extractionYC = 33.0
extractionRadius = 2.5
scienceOneDExtraction = True
scienceDirectoryList = []
telluricDirectoryList = []
calibrationDirectoryList = []
[nifsPipelineConfig]
sort = False
calibrationReduction = False
telluricReduction = False
scienceReduction = True
telluricCorrection = False
fluxCalibration = False
merge = False
telluricCorrectionMethod = 'gnirs'
fluxCalibrationMethod = 'gnirs'
mergeMethod = ''
[sortConfig]
rawPath = '/Users/nat/data/TUTORIAL'
program = ''
proprietaryCookie = ''
skyThreshold = 2.0
sortTellurics = True
telluricTimeThreshold = 5400
[calibrationReductionConfig]
baselineCalibrationStart = 1
baselineCalibrationStop = 4
[telluricReductionConfig]
telStart = 1
telStop = 5
telluricSkySubtraction = True
[telluricCorrectionConfig]
telluricCorrectionStart = 1
telluricCorrectionStop = 9
hLineMethod = 'vega'
hLineInter = False
continuumInter = False
telluricInter = False
tempInter = False
standardStarSpecTemperature = ''
standardStarMagnitude = ''
standardStarRA = ''
standardStarDec = ''
standardStarBand = ''
[fluxCalbrationConfig]
fluxCalibrationStart = 1
fluxCalibrationStop = 6
[mergeConfig]
mergeStart = 1
mergeStop = 3
mergeType = 'median'
use_pq_offsets = True
im3dtran = True
# Good luck with your Science!
And run the nifsPipeline with:
runNifty nifsPipeline config.cfg
nifsTelluric Correction: To only derive and apply a telluric correction use a config.cfg file like this: Make sure to populate scienceDirectoryList, telluricDirectoryList and calibrationDirectoryList before running!
# Nifty configuration file.
#
# Each section lists parameters required by a pipeline step.
manualMode = False
over = False
extractionXC = 15.0
extractionYC = 33.0
extractionRadius = 2.5
scienceOneDExtraction = True
scienceDirectoryList = []
telluricDirectoryList = []
calibrationDirectoryList = []
[nifsPipelineConfig]
sort = False
calibrationReduction = False
telluricReduction = False
scienceReduction = False
telluricCorrection = True
fluxCalibration = False
merge = False
telluricCorrectionMethod = 'gnirs'
fluxCalibrationMethod = 'gnirs'
mergeMethod = ''
[sortConfig]
rawPath = '/Users/nat/data/TUTORIAL'
program = ''
proprietaryCookie = ''
skyThreshold = 2.0
sortTellurics = True
telluricTimeThreshold = 5400
[calibrationReductionConfig]
baselineCalibrationStart = 1
baselineCalibrationStop = 4
[telluricReductionConfig]
telStart = 1
telStop = 5
telluricSkySubtraction = True
[telluricCorrectionConfig]
telluricCorrectionStart = 1
telluricCorrectionStop = 9
hLineMethod = 'vega'
hLineInter = False
continuumInter = False
telluricInter = False
tempInter = False
standardStarSpecTemperature = ''
standardStarMagnitude = ''
standardStarRA = ''
standardStarDec = ''
standardStarBand = ''
[fluxCalbrationConfig]
fluxCalibrationStart = 1
fluxCalibrationStop = 6
[mergeConfig]
mergeStart = 1
mergeStop = 3
mergeType = 'median'
use_pq_offsets = True
im3dtran = True
# Good luck with your Science!
And run the nifsPipeline with:
runNifty nifsPipeline config.cfg
nifsFluxCalibration: To only do a flux calibration use a config.cfg file like this: Make sure to populate scienceDirectoryList, telluricDirectoryList and calibrationDirectoryList before running!
# Nifty configuration file.
#
# Each section lists parameters required by a pipeline step.
manualMode = False
over = False
extractionXC = 15.0
extractionYC = 33.0
extractionRadius = 2.5
scienceOneDExtraction = True
scienceDirectoryList = []
telluricDirectoryList = []
calibrationDirectoryList = []
[nifsPipelineConfig]
sort = False
calibrationReduction = False
telluricReduction = False
scienceReduction = False
telluricCorrection = False
fluxCalibration = True
merge = False
telluricCorrectionMethod = 'gnirs'
fluxCalibrationMethod = 'gnirs'
mergeMethod = ''
[sortConfig]
rawPath = '/Users/nat/data/TUTORIAL'
program = ''
proprietaryCookie = ''
skyThreshold = 2.0
sortTellurics = True
telluricTimeThreshold = 5400
[calibrationReductionConfig]
baselineCalibrationStart = 1
baselineCalibrationStop = 4
[telluricReductionConfig]
telStart = 1
telStop = 5
telluricSkySubtraction = True
[telluricCorrectionConfig]
telluricCorrectionStart = 1
telluricCorrectionStop = 9
hLineMethod = 'vega'
hLineInter = False
continuumInter = False
telluricInter = False
tempInter = False
standardStarSpecTemperature = ''
standardStarMagnitude = ''
standardStarRA = ''
standardStarDec = ''
standardStarBand = ''
[fluxCalbrationConfig]
fluxCalibrationStart = 1
fluxCalibrationStop = 6
[mergeConfig]
mergeStart = 1
mergeStop = 3
mergeType = 'median'
use_pq_offsets = True
im3dtran = True
# Good luck with your Science!
And run the nifsPipeline with:
runNifty nifsPipeline config.cfg
nifsMerge Cube Merging: To only merge final data cubes use a config.cfg file like this: Make sure to populate scienceDirectoryList, telluricDirectoryList and calibrationDirectoryList before running!
# Nifty configuration file.
#
# Each section lists parameters required by a pipeline step.
manualMode = False
over = False
extractionXC = 15.0
extractionYC = 33.0
extractionRadius = 2.5
scienceOneDExtraction = True
scienceDirectoryList = []
telluricDirectoryList = []
calibrationDirectoryList = []
[nifsPipelineConfig]
sort = False
calibrationReduction = False
telluricReduction = False
scienceReduction = False
telluricCorrection = True
fluxCalibration = False
merge = True
telluricCorrectionMethod = 'gnirs'
fluxCalibrationMethod = 'gnirs'
mergeMethod = ''
[sortConfig]
rawPath = '/Users/nat/data/TUTORIAL'
program = ''
proprietaryCookie = ''
skyThreshold = 2.0
sortTellurics = True
telluricTimeThreshold = 5400
[calibrationReductionConfig]
baselineCalibrationStart = 1
baselineCalibrationStop = 4
[telluricReductionConfig]
telStart = 1
telStop = 5
telluricSkySubtraction = True
[telluricCorrectionConfig]
telluricCorrectionStart = 1
telluricCorrectionStop = 9
hLineMethod = 'vega'
hLineInter = False
continuumInter = False
telluricInter = False
tempInter = False
standardStarSpecTemperature = ''
standardStarMagnitude = ''
standardStarRA = ''
standardStarDec = ''
standardStarBand = ''
[fluxCalbrationConfig]
fluxCalibrationStart = 1
fluxCalibrationStop = 6
[mergeConfig]
mergeStart = 1
mergeStop = 3
mergeType = 'median'
use_pq_offsets = True
im3dtran = True
# Good luck with your Science!
And run the nifsPipeline with:
runNifty nifsPipeline config.cfg
Preparing the .cfg Input File¶
Nifty reads data reduction parameters with a config parser developed by Michael Foord. See http://www.voidspace.org.uk/python/configobj.html for full documentation on the parser.
Interactive Input Preparation¶
The best way to learn about what each config file parameter does is to populate an input file interactively by typing:
runNifty nifsPipeline -i
This will, for each parameter, print an explanation and supply a default parameter that you can accept by pressing enter. The output file is named “config.cfg”.
An Example Input File¶
Nifty includes a default configuration file in the runtimeData/ directory. As of v1.0b2, It looks like this: .. TODO(nat): This is out of data! Update this!
# Nifty configuration file.
#
# Each section lists parameters required by a pipeline step.
manualMode = False
over = False
merge = True
scienceDirectoryList = []
telluricDirectoryList = []
calibrationDirectoryList = []
[nifsPipelineConfig]
sort = True
calibrationReduction = True
telluricReduction = True
scienceReduction = True
[sortConfig]
rawPath = ''
program = ''
skyThreshold = 2.0
sortTellurics = True
date = ''
copy = ''
[calibrationReductionConfig]
baselineCalibrationStart = 1
baselineCalibrationStop = 4
[telluricReductionConfig]
telStart = 1
telStop = 6
telluricSkySubtraction = True
spectemp = ''
mag = ''
hline_method = 'vega'
hlineinter = False
continuuminter = False
[scienceReductionConfig]
sciStart = 1
sciStop = 6
scienceSkySubtraction = True
telluricCorrectionMethod = ''
telinter = False
fluxCalibrationMethod = ''
use_pq_offsets = True
im3dtran = True
# Good luck with your Science!
Data Reduction Examples¶
Observations of Titan¶
Recipe used: defaultConfig.cfg
Observations of a Moderate Redshift Galaxy¶
Recipe used: defaultConfig.cfg
Let’s reduce NIFS data of a moderate redshift galaxy, located at z ~ 1.284. This is a faint target, so after making individual cubes we use the reported telescope P and Q offsets to blindly merge our final cubes.
As this program is out of its proprietary period and available on the Gemini Public Archive, we can use the defaultConfig.cfg configuration file and specify its program ID to reduce it.
runNifty -f GN-2013A-Q-62
We could also launch the reduction from a provided configuration file.
Contents of the configuration file:
TODO(nat): When finalized fill this out!
To launch the reduction:
runNifty <configurationFile>
Tutorials¶
H Line Removal¶
The H-line removal can be done non-interactively, but it is advised that this be performed interactively and using the “vega_tweak” method in order to accurately scale the vega spectrum. In the interactive mode for the initial scaling and call to “telluric” these are the cursor keys and colon commands (from http://iraf.net/irafhelp.php?val=telluric&help=Help+Page):
- ? - print help
- a - automatic RMS minimization within sample regions
- c - toggle calibration spectrum display
- d - toggle data spectrum display
- e - expand (double) the step for the current selection
- q - quit
- r - redraw the graphs
- s - add or reset sample regions
- w - window commands (see :/help for additional information)
- x - graph and select from corrected shifted candidates
- y - graph and select from corrected scaled candidates
- :help - print help
- :shift [value] - print or reset the current shift
- :scale [value] - print or reset the current scale
- :dshift [value] - print or reset the current shift step
- :dscale [value] - print or reset the current scale step
- :offset [value] - print or reset the current offset between spectra
- :sample [value] - print or reset the sample regions
- :smooth [value] - print or reset the smoothing box size
To decrease the scale or shift value, the cursor must be under the spectrum and to increase these values the cursor must be above the spectrum. Occasionally, this will not work in which case the value can be designated with a colon command.
If using the vega_tweak or other interactive line removal method, the lines can be removed in a splot environment (commands found here: http://stsdas.stsci.edu/cgi-bin/gethelp.cgi?splot.hlp). The most useful commands for this are:
- k + (g, l or v)
Mark two continuum points and fit a single line profile. The second key selects the type of profile: g for gaussian, l for lorentzian, and v for voigt. Any other second key defaults to gaussian. The center, continuum at the center, core intensity, integrated flux, equivalent width, and FWHMs are printed and saved in the log file. See d for fitting multiple profiles and - to subtract the fit.
- w
Window the graph. For further help type ? to the “window:” prompt or see help under gtools. To cancel the windowing use a.
It is necessary to press ‘i’ before ‘q’ once the h-lines have been removed in order to save the changes.
Custom Telluric Corrections¶
You can supply your own continuum-normalized telluric correction spectrum by placing a “telluricCorrection.fits” one D spectra and a “fit.fits” that you used to normalize that spectra in the science observation directory. Both spectra must be 2040 pixels long and have the data extension located in header unit zero. Note that overwrite must be turned off for this to work.
Merging Data Cubes¶
Nifty offers a few ways to merge data cubes. These are all contained in the nifsMerge.py script.
Note: If cubes are not transposed each call to iraf.imcombine() can take 25 minutes or more. The current implementation is much slower at combining when cubes have a y-offset.
Cubes Were Shifted by Hand with QFitsView or Similar
A user can shift cubes by hand and add the prefix “shift” to the cube name. The pipeline will automatically find these cubes and combine them with gemcube.
If no “shift”-prefixed cubes exist the user has two more choices to make. The first is to generate offsets automatically or to provide an offsets file by hand.
Generating an offsets.txt File
If use_pq_offsets is True in the config.cfg file, Nifty will determine offsets automatically from the POFFSET and QOFFSET entry of each cubes .fits header. Otherwise, Nifty will pause and wait for you to provide a suitably formatted offsets.txt file in the scienceObjectName/Merged/date_obsid/ directory.
Using iraf.im3dtran()
Cubes have been found to combine ~50 times faster when the y and lambda axis are swapped with iraf.im3dtran(). In our tests we found it took ~25 minutes to merge cubes without transposition and ~0.5 minutes to merge cubes in a tranposed state.
We have found the cubes produced with and without tranposition to be identical. We have made the default not to use transposition but we urge further testing.
Known Issues¶
nifsPipeline.py¶
nifsSort.py¶
Two things can routinely cause nifsSort to fail.
Object and Sky frame differentiation
Relevant warning:
..code-block:: text
- WARNING in sort: science ” <scienceObservationName>
- in ” <currentWorkingDirectory> does not have a scienceFrameList.”) I am trying to rewrite it with zero point offsets.
Solution:
- Change the skyThreshold parameter (given in arc seconds) and re-run sort.
If the sorting script does not create a skyFrameList in the object or telluric observation directories this means that the offsets between sky frames and object frames were different than expected. A skyFrameList can be manually created and saved in the appropriate directory, or the skyThreshold parameter modified.
Telluric and Science Frame Matching
Relevant warning:
..code-block:: text
- WARNING in sort: no tellurics data found for science ” <scienceImageName>
- in ” <currentWorkingdirectory
Solution:
- Raise telluricTimeThreshold to something above 5400 seconds.
By default standard star observations are matched with each science frame if they are within 1.5 hours (5400) seconds in UT start time. Sometimes just a few science frames will be outside that threshold.
If you see the relevant warning after running sort, you will have to raise the telluricTimeThreshold in the config.cfg file if you want to do telluric corrections.
nifsBaselineCalibration.py¶
- Long data file path names are not fed to IRAF tasks. It seems IRAF task parameters
must be 99 characters or less. Nifty’s data files are stored in the Astroconda environment packages directory; for example, on my system it is “/Users/nat/miniconda2/envs/niftypip/lib/python2.7/site-packages/nifty/pipeline/”. If you have a long username, for example, this can cause the path name to be too long to be parsed by iraf. Temporary fix: I have made the names of all the data files short enough for it to work okay on my system. Please let me know if this seems to be causing you issues and I can come up with a better fix.
nifsReduce.py¶
- z-band data is not capable of a flux calibration (yet!).
- Seems to be missing the first peak of the ronchi slit when iraf.nfsdist() is run interactively. This does not seem to be a problem.
- We noticed that iraf.nfsdist() produced different results when run interactively and non-interactively. To test check the log for iraf.nfsdist() output and make sure it is identifying 8/8 or 9/9 peaks every time.
- iraf.nftelluric() was not built to be run automatically. A lightly tested modified version that allows an automatic telluric correction is included in the extras directory but more testing is needed. For now applyTelluricPython() is recommended.
nifsMerge.py¶
- When overwrite is turned on, merging the final cubes from multiple directories redundantly repeats.
This is a good quick fix for someone to implement.
nifsTelluric.py¶
nifsTelluric.py and nifsFluxCalibrate.py rely on several IRAF tasks finding information in the correct image header. If this implicit header data matching changes in future IRAF implementations these tasks will break. A fix could be to explicitly specify the data header for each task. TODO(nat): Try to do this before you leave.
- iraf.imarith() is having some strange errors. I’m using astropy and numpy instead to do the 2 imarith steps.
- See nifsFluxCalibrate for the iraf.gemini() and iraf.imarith() bug.
nifsFluxCalibrate.py¶
- If iraf.gemini() is called in nifsTelluric.py and the two steps are run back to back,
iraf.imarith() does not work in nifsFluxCalibrate.py. iraf.imarith can’t seem to open the result of step 3; it throws this error:
..code-block:: text
3_BBodyN20100401S0182 is not an image or a number
When I ran nifsTelluric.py and nifsFluxCalibrated.py back to back, using nifsPipeline.py as a wrapper, iraf.imarith() worked when iraf.gemini() was commented out in nifsTelluric.py. It crashed with the above error when iraf.gemini() was uncommented.
I’ve implemented a just-as-good solution using astropy and numpy.
nifsUtils.py¶
General Issues¶
- A longstanding bug (see astropy ) in astropy has made it difficult to build Nifty as a binary executable.
- The conversion of print statements to logging.info() statements was messy. Some of these may still not be properly converted and will throw nasty tracebacks. However these seem to have no effect on the functionioning of the code.
- Logging is still not perfect. One or two iraf tasks are sending their log files to “nifs.log” instead of “Nifty.log”.
Maintaining Nifty¶
Documentation¶
Right now there exists four forms of documentation.
Paper
README.rst
.rst Files in the docs/ directory
This file, others like it in the docs/ directory and the README are written in reStructuredText. This markup language integrates well with Python’s automatic documentation builder (we used Sphinx) and Github as well as being human readable. You can read more about reStructuredText here.
Comments and DocStrings in Source Code
Tests¶
This is a todo. Currently we do not have automated tests.
Pipeline Structure¶
See the Nifty paper for a high level overview. Nifty general runs with the following procedure:
- A script in the scripts/ directory is called from the command line.
- This script imports the relevant pipeline and steps from the nifty/pipeline/ and nifty/pipeline/steps/directories.
- The script then launches the appropriate pipeline,
- This pipeline launches the appropriate steps,
- These steps launch the appropriate routines, and
- These routines launch the appropriate sub-routines.
Nifty is built at the lowest level from Python and IRAF subroutines. It is built so that it is relatively easy to change the implementation of the underlying tasks.
Updates¶
To update Nifty, do five things:
- Try to do your development in a new branch or fork, not the master branch of the repository
- Before uploading, do a few test data reductions.
- Pick an appropriate version number based on semantic versioning; update the setup.py
- Commit all changes to GitHub
- Create a new Github Release
- `Upload the latest version to PyPi.org < https://packaging.python.org/tutorials/distributing-packages/>`_
..code-block:: text
rm -r dist build # Clean up old files python setup.py bdist_wheel # Build python wheels twine upload dist/* # Upload to PyPi.org
Version Numbers
Nifty uses semantic versioning(see http://semver.org/). This means version numbers come in
MAJOR.MINOR.PATCH
In brief, when releasing a version of Nifty that is not backward-compatible with old test recipes, or changes break the public API, it is time to increment the MAJOR version number.
..TODO(nat): maybe make this a little clearer.
Code Conventions¶
Nifty was partly written using atom. Error messages, warnings and updates were partly written using templates in the included snippets.cson file.
Where possible, nat used 2D (and higher) dimensional lists to implement error checking flags. These are particularly prominent in sort.
Variables and functions were named using conventions in the Python Style Guide. Specifically a mix of camelCase and lower_case_with_underscores was used.
Code style was influenced by the Google Python Style Guide.
Nifty uses the Google docstring style. Examples of docstrings can be found here.
Other Python comments use the following convention:
- A # is followed by a space and a capital letter.
- All comments end in a period where possible.
Future Work¶
Throughout the code, ncomeau has placed many TODO notes. These are things that should be reviewed at some point.
Future work:
- Implement more telluric and flux calibration methods.
- Implement instrument signature removal routine.
- Implement cosmic ray removal routine.
- Implement differential atmospheric refraction correction routine.
- Implement full automatic Gemini (on server) reduction routine.
- Implement a “don’t save intermediate products” switch
- Object Oriented rewrite; see the JWST calibration pipeline. Pipelines, Steps, Routines and Tasks may implemented better as software objects.
- XDGNIRS integration and NDMAPPER (James EH Turner) integration
- Analysis tools: automatic velocity field? Dispersion?
- Python 3 compatability(if possible)
- Compiling as a self-contained executable
- Full AstroConda integration
Changelog¶
All notable changes to this project will be documented in this file.
The format is based on Keep a Changelog and this project adheres to Semantic Versioning.
Unreleased¶
All in-development changes will be tracked here.
- Adding unit tests for each step and integration test for pipeline.
1.0.0 - 2017-09-12¶
First production release. Works fairly smoothly once raw data is located and sorted properly.
- Rigorously tested first type of cube merging; not final wave shifting of cubes; with dummy data.
- Finished integrating multiple types of cube merging.
1.0b4 - 2017-09-12¶
Much refined and patched Beta release. Still not finished but much more robust.
- Verified overwrite; it seems to be safe to use now.
- Fixing telluric correction and absolute flux calibration.
- Added 1D extraction routine.
- Preliminary addition of three types of cubes and cube merging.
1.0b1 - 2017-09-08¶
Preliminary Beta release.
- Syntax errors mean this version will not compile.
- Fixing merge flip due to differences between NIFS + ALTAIR and NIFS w/o ALTAIR on the bottom port.
1.0a1 - 2017-08-31¶
Preliminary Alpha release.
- .whl uploaded to PIP, docs uploaded to
ReadTheDocs and preliminary DOI assigned.
API¶
Note: I didn’t have time to implement this using Sphinx automodule. Nifty has fairly good docstrings and you can use individual steps, routines and tasks by importing them. This is a todo.


WHAT DREAMS MAY COME A Film Review by Boyd Petrie
Out of 4 stars: ***1/2 (3.5 Stars)
Many people will not find much to like in WHAT DREAMS MAY COME, the new film by visionary director Vincent Ward. Most will come to see the computer animated landscapes and vibrant colors. But little do they know (as I so plainly found out) that this has quite a complex story to tell. Walking out of the theater, I could see the audience's disgust... one member even had to be awakened after the film ended. Don't believe the previews that you see... this is definitely not a film for everyone.
This is quite possibly one of the most adult-oriented films to come out in recent years. Kids will get bored with the slow plotting and the complex storyline. The plot is just as fluid as the heaven that Ward presents to us. It goes back and forth in time, as if it has no boundaries. Think of the film CITY OF ANGELS. Now add a more complex screenplay and a more unique vision. Both films deal with the afterlife, but I doubt WHAT DREAMS MAY COME will do well at the box office. Costing around $85 million to make, the film would have to do extremely well in order to make it's money back. But due to it's story, I doubt it will. For everyone who thought TITANIC's story was too simple and cliche, here is proof that if James Cameron had written a more complex screenplay, it may not have done nearly as well.
But don't get me wrong... I hope the film does do well. It's a vision of pure visceral enjoyment that hardly ever gets put to the screen. I doubt most of us could have thought of this place, even in our own mind. WHAT DREAMS MAY COME is the second best film of the year when it comes to visuals. The only film that surpasses it is DARK CITY. Full of rich, shocking colors, we get to see a heaven that most of us would probably die to get to.
WHAT DREAMS MAY COME begins with two boats colliding on a lake. Chris "Christy" Nielsen (Robin Williams) is startled by the sudden jolt, but is even more startled by the beauty of the woman in the other boat. Annie (Annabella Sciorra) spies Chris, as well, and both eventually bond and get married. Annie is an artist, whose paintings are colorful, lush, and surrealistic. Chris is a doctor and loves Annie more than life itself. They also have two children, Marie (Jessica Brooks) and Ian (Josh Paddock). But one day, the two children are killed in a car crash, and it almost destroys Annie. She tries to commit suicide, but fails, and is then put in an institution. Chris copes with the problem by realizing they aren't around anymore, and nothing will change that. Just as Annie gets her life back in order, Chris is killed while trying to save the life of a car crash victim.
Chris goes to heaven, or his version of heaven, rather. Guided by Albert (Cuba Gooding, Jr.), Chris explores his new surroundings with pure delight and joy. That is, until he realizes how miserable he is without Annie. Prior to heaven, he would try to comfort Annie, but the more he was around, the more pain she felt. Chris decides to leave her alone. Little does he realize what will happen next. I'm not about to say, because the plot point is crucial to the rest of the story (many critics, however, give it away). Certainly, Chris dying is crucial to the plot, but they tell you that he dies in the previews.
Story is not necessarily important for this movie to work, because it deals with the afterlife. However, strangely, virtually nothing is heard of God or the Devil. A couple of comments here and there, but the story maintains its focus on Chris and his search for the love of his life. "We're soul mates!" Chris exclaims. Heaven, in movies, is almost always depicted as a glowing city of white, purity, and love. Usually, it also looks like it rests among the clouds. But WHAT DREAMS MAY COME goes a different route. It shows us a heaven that most of us have never seen before.  His thoughts can make anything real, and he makes the paintings Annie drew become his heaven. "I've never seen anyone use real paint before," Albert says. Equally good as the depictions of hell which cast away the normal stereotypes of fire and brimstone. Instead, it's a state of being. In one gloriously horrific scene, Chris and his "tracker" (Max von Sydow) arrive at a sea of faces. Thousands of heads are stuck above ground, their bodies somewhere else. Mostly dead silent, some quips are made, almost as if to lighten the mood. It's truly a frightening sequence.
Production designer Eugenio Zanetti is definitely going to be up for an Oscar nomination. Using state of the art computer technology, worlds are created for exploration. Sometimes, some scenes play out as if they are only there for the visual impact. It's not necessary to be there, but we appreciate seeing it. Costume designer Yvonne Blake (who also appears in the film) has done an incredible job providing some interesting and colorful costumes. Cinematographer Eduardo Serra, whose work was last seen in the luscious WINGS OF THE DOVE, has a difficult job, as most cinematographers do working with special effects. But Serra's entire universe is a computer generated image, and he does a masterful job. Writer Ron Bass, adapting from the novel by Richard Matheson, provides a very fluid screenplay with no real set plot. The story is extremely vague in its details, allowing viewers to think for themselves about the meaning. And director Vincent Ward puts it all together into his final vision. WHAT DREAMS MAY COME is a good example of German expressionism which may just turn off a good portion of the audience. Your average movie goer more than likely isn't used to expressionistic techniques. The film will also definitely draw attention from religious people, but they shouldn't take it too far. It is, after all, just a movie.
Robin Williams has continuously impressed with his dramatic performances, while his comedic roles have been suffering. His comedy is perfection when he makes up his own stuff, but when is confined by a screenplay, he isn't quite as effective. But drama is really his strong point, and you can see that here. It's doubtful he'll get another Oscar nomination, but I wouldn't really mind if he did. The real surprise here is Annabella Sciorra who impressed last year with COP LAND. This may be her breakout role and may garner her some much needed attention. It's also quite possible that she could get an Oscar nomination. However, the Academy doesn't like to award performances for these types of films. Cuba Gooding, Jr. has been better, but he's certainly not distracting. Max von Sydow is underused, as are Jessica Brooks and Josh Paddock. A treat for some movie goers is to see Werner Herzog appear (if they even recognize him) as Chris' father lost in the sea of faces. It's not hard to see why Herzog would be attracted to this film, considering he thinks that audiences are starving for great images. Overall, it's Williams and Sciorra's film.
WHAT DREAMS MAY COME is rated PG-13 for thematic elements involving death, some disturbing images, language, and some partial nudity. The film is definitely aimed at a more adult audience. Some will find the plot distracting. Some will find the visuals absolutely glorious. And some will find both. The only real problem with the film, that I could see, was that it slows down considerably during the midsection, just after we have been immersed in the visuals and before the search for Annie begins.  In actuality, the title is from a soliloquy in HAMLET. Just thought I should let you know.
-- Respect's Movie Reviews http://www.aros.net/~respect/movies.html ------------------- Baraka's Mortal Kombat 4 Page http://www.aros.net/~respect/mk4/mk4.html -------------------<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


:: com :: sun :: star :: script ::
|
| interface XLibraryContainerPassword |
|
- Description
- Extension of XLibraryContainer to provide password functionality.
This interface should be implemented together with XLibraryContainer2
|
| Methods' Summary |
| isLibraryPasswordProtected |
Returns true if the accessed library item is protected
by a password.
If a library with the this name doesn't exist a
com::sun::star::container::NoSuchElementException is thrown.
|
| isLibraryPasswordVerified |
Returns true if the accessed library item is protected by a
password (see isLibraryPasswordProtected) and the password
was already verified with verifyLibraryPassword or if an
initial password was set with changeLibraryPassword.
If a library with the this name doesn't exist a
com::sun::star::container::NoSuchElementException is thrown.
If the library exists but isn't password protected a
com::sun::star::lang::IllegalArgumentException is thrown.
|
| verifyLibraryPassword |
Verifies the library's password. If the correct password
was passed, the method returns true and further calls to
isLibraryPasswordVerified will also return true.
If a library with the this name doesn't exist a
com::sun::star::container::NoSuchElementException is thrown.
If the library exists but isn't password protected a
com::sun::star::lang::IllegalArgumentException is thrown.
If the library password is already verified a
com::sun::star::lang::IllegalArgumentException is thrown.
|
| changeLibraryPassword |
Changes the library's password.
If the library wasn't password protected before:
The OldPassword parameter has to be an empty string.
Afterwards calls to isLibraryPasswordProtected and
isLibraryPasswordVerified for this library will
return true.
If the library already was password protected:
The OldPassword parameter has to be set to the
previous defined password. If then the NewPassword
parameter is an empty string the library password
protection will be disabled afterwards (afterwards
calls to isLibraryPasswordProtected for this library
will return false). If the NewPassword parameter is
not an empty string it will accepted as the new
password for the library.
If a library with the this name doesn't exist but isn't
com::sun::star::container::NoSuchElementException is thrown.
If the library exists and is password protected and a
wrong OldPassword is passed to the method a
com::sun::star::lang::IllegalArgumentException is thrown.
If the library exists and isn't password protected and
the OldPassword isn't an empty string or the library is
read only a
com::sun::star::lang::IllegalArgumentException is thrown.
|
| Methods' Details |
isLibraryPasswordProtected
- Description
- Returns true if the accessed library item is protected
by a password.
If a library with the this name doesn't exist a
com::sun::star::container::NoSuchElementException is thrown.
|
|
isLibraryPasswordVerified
- Description
- Returns true if the accessed library item is protected by a
password (see isLibraryPasswordProtected) and the password
was already verified with verifyLibraryPassword or if an
initial password was set with changeLibraryPassword.
If a library with the this name doesn't exist a
com::sun::star::container::NoSuchElementException is thrown.
If the library exists but isn't password protected a
com::sun::star::lang::IllegalArgumentException is thrown.
|
|
verifyLibraryPassword
- Description
- Verifies the library's password. If the correct password
was passed, the method returns true and further calls to
isLibraryPasswordVerified will also return true.
If a library with the this name doesn't exist a
com::sun::star::container::NoSuchElementException is thrown.
If the library exists but isn't password protected a
com::sun::star::lang::IllegalArgumentException is thrown.
If the library password is already verified a
com::sun::star::lang::IllegalArgumentException is thrown.
|
|
changeLibraryPassword
- Description
- Changes the library's password.
If the library wasn't password protected before:
The OldPassword parameter has to be an empty string.
Afterwards calls to isLibraryPasswordProtected and
isLibraryPasswordVerified for this library will
return true.
If the library already was password protected:
The OldPassword parameter has to be set to the
previous defined password. If then the NewPassword
parameter is an empty string the library password
protection will be disabled afterwards (afterwards
calls to isLibraryPasswordProtected for this library
will return false). If the NewPassword parameter is
not an empty string it will accepted as the new
password for the library.
If a library with the this name doesn't exist but isn't
com::sun::star::container::NoSuchElementException is thrown.
If the library exists and is password protected and a
wrong OldPassword is passed to the method a
com::sun::star::lang::IllegalArgumentException is thrown.
If the library exists and isn't password protected and
the OldPassword isn't an empty string or the library is
read only a
com::sun::star::lang::IllegalArgumentException is thrown.
|
|
Top of Page
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


Stackoverflow based wiki
Popularity index based on effective score
Based on user reputation on StackOverFlow


Global Data
Local Data
Country Data
State Data
Covid Searched Location Tracker
CONFIRMED CASES:-
TOTAL DEATHS:-
RECOVERED:-
TOTAL TESTS:-
CRITICAL CASES:-
ACTIVE CASES:-