 This content is a little bit longer.
Last updated 3 mins ago
Card Title
This card has supporting text below as a natural lead-in to additional content.
Last updated 3 mins ago
Card Title
This is a wider card with supporting text below as a natural lead-in to additional content. This card has even longer content than the first to show that equal height action.
Last updated 3 mins ago
Using utilities
Card Title
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam.

Go somewhereCards Groups
Card Title
This is a wider card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
Last updated 3 mins ago
Card Title
This card has supporting text below as a natural lead-in to additional content.
Last updated 3 mins ago
Card Title
This is a wider card with supporting text below as a natural lead-in to additional content. This card has even longer content than the first to show that equal height action.
Last updated 3 mins ago
Solid Cards
Primary card Title
Some quick example text to build on the card Title and make up the bulk of the card's content.
Secondary card Title
Some quick example text to build on the card Title and make up the bulk of the card's content.
Success card Title
Some quick example text to build on the card Title and make up the bulk of the card's content.
Danger card Title
Some quick example text to build on the card Title and make up the bulk of the card's content.
Warning card Title
Some quick example text to build on the card Title and make up the bulk of the card's content.
Info card Title
Some quick example text to build on the card Title and make up the bulk of the card's content.
Light card Title
Some quick example text to build on the card Title and make up the bulk of the card's content.
Dark card Title
Some quick example text to build on the card Title and make up the bulk of the card's content.


What is phpDocumentor?
phpDocumentor 2 is a tool with which it is possible to generate documentation from your PHP source code. With this you can provide your consumers with more information regarding the functionality embedded within your source and not just what is usable to them from your user interface.
Documentation generated by phpDocumentor 2 does not aim to be a replacement for conventional documentation but is rather supplemental, or reference, documentation.This proves to be useful in the following, example, situations:
- Sets of libraries or applications providing an API, such as phpDocumentor 2 itself
- Frameworks, such as Zend Framework or Symfony
- Pluggable architectures, such as WordPress or PyroCMS
- Long-running, complex projects, to help you find the right function or method for the job
Templates
phpDocumentor 2 contains an incredibly flexible template system which enables you to alter your output in any way imaginable. This can range from simply applying your own branding for the HTML output by merely altering a couple of CSS files to determining which types of output are generated and where they are made available.
Code Analysis
phpDocumentor 2 is capable of extracting interesting information and present those in the form of graphs and reports. The following are currently supported:
- An inheritance diagram showing all subclassing and implementing of interfaces.
- Reporting errors in your source code's inline documentation.
- Reporting which elements are marked as deprecatedReporting where TODO's are placed in your code and what is to be done.
This list will only grow in the future to help you determine where to invest your resources in order to make your code more stable and maintainable.


So, the Main Scala Website has a “tour” of the features of Scala. I liked the idea, but found a lot of the examples and descriptions a bit terse and uninspiring (some of them are downright confusing). However, I really wanted to learn about these features. So, I set about understanding each feature, trying to answer the question “What problem does this solve?”. The results are here at www.naildrivin5.com/scalatour. This site was constructed using my homebrew wiki software, Halen (which I created to test out my Gliffy Ruby client).
It was a fun experience. As someone coming from Java application development (and who knows enough Ruby to feel some pain in Java), I tried hard to map the features to real-world problems a “blue-collar developer” might be facing. A lot of Scala enthusiasts seem to be functional programming nerds, and I know FP can turn a lot of people off. I think Scala is a great way to learn and appreciate functional programming without having to swallow a huge amount of info at once. So, I figured approaching Scala’s features from a different angle would be useful.
I did have to supplement my learning with info from Odersky’s awesome Programming Scala book, but most of what I learned, I learned by playing around with code; all the code on the site should compile and run (at least in Scala 2.7.x). The coolest thing was that by “touring” all of Scala’s (often weird) features, I got a good feel for how they all fit together. The language feels like a very elaborate Rube-Goldberg Machine that ends up being rather elegant. I feel that instead of casting Scala as a functional language, or a hybrid language, I would say that Scala is “static typing done right (or as right as is possible)”.
The way Scala allows for duck typing, for example, is really cool, and something I think Ruby code could benefit from.
Stuff like type variance is pretty heavy stuff, but when you dig into, and understand how functions are implemented, it ends up making some sense. I even found a “real world” use for explictly-typed self-references, which I thought was actually a sick joke for a while :) Anyway, I hope that what I’ve learned doing this will be helpful to others.


"Scream" (1996)
A Film Review by Jason Wallis
"Scream" * * * * Starring Neve Campbell, Courtney Cox, David Arquette, Matthew Lillard, Drew Barrymore, Rose McGowen, Skeet Ulrich and Henry Winkler Directed by Wes Craven
"Scream" begins with one of the best edited and most frightening scenes ever put on film. In it's opening, we are introduced to Drew Barrymore (with a cool new cut), playing a teen home alone, ready to cook up some popcorn and relax with a nice little horror flick. All of a sudden, the phone rings; she answers it, not knowing that on the other end is a blood-thirsty psychopath. He playfully flirts with her, always keeping a frighteningly monotone voice. When he asks her name, she asks why he wants to know. His response: because I want to know who I'm looking at. Terror ensues.
Now, if you want to see this flick because of Drew, don't even bother because she, needless to say, gets done away with in the first fifteen minutes. Quite gruesomely, I might add. But the violence in this film is not mean-spirited gore as in such shockers as "Friday the 13th" and the like. Because the film is so campy and self aware of itself, all the violence is justified. But, tho a tad on the violent side, "Scream" does not contain a gratuitous amount of gore. We only think we see it. It has potential to be much, much gorier. But it isn't, and that's one of the reasons why it's so much fun to watch. Director Wes Craven finds the perfect balance between buckets of blood and no violence at all. In other words, it's done with some taste.
Anyway, let me get back to the point. Most modern horror flicks concentrate on the gross-out factor and try to out-do each other on how much female nudity you can squeeze into one film. Most also feature very bland characters. In "Scream", the actors add just the right amount of charisma to their characters. Special kudos to Matthew Lillard, who plays Stu (possibly the coolest guy in the history of cinema). Matt doesn't make Stu just another horny teenager; he adds something special that makes him different from the rest. I may be going out on a limb here (correction: I know I am), but I think this is the performance that should have captured last year's Oscar for Best Supporting Actor (Cuba was good and all, but he didn't make an unforgettable character like Matt Lillard did. I mean, "show me the money"? Gimme a break). But don't get me wrong; there were other deserving performances (particularly Dwight Yokham's awesome portrayle of an abusive boyfriend in "Sling Blade" - but that's for another review), but none did as great of a job as Lillard.
It is extremely refreshing to see a movie like this; a fun, scary, well executed (no pun intended) and incredibly enjoyable slasher flick. The plot of the movie is simple: a crazed sociopath has seen one to many scary movies and is now going around dressed as Father Death (one of the scariest costumes since Michael's mask in "Halloween") picking off teen after teen. His first victim (Drew Barrymore) went to a high school with a principal non other than the Fonz himself, Henry Winkler. The killer begins to terrorize a handful of students from that school, particularly concentrating on Neve Campbell (who has a boyfriend barring a striking resemblance to Johnny Depp from Craven's other masterpiece, "A Nightmare on Elm Street").
I will not say anything more because that would be giving away the movie, and I wouldn't even dream of doing that. The main thing that makes "Scream" different from all those other horror flicks is that it works on two levels. First of all, like I said, it is a splendid slasher film. Secondly, it is an excellent homage to other horror movies (i.e. "Prom Night", "Halloween", etc.). There's probably about fifty in-jokes in the first hour alone. But "Scream" is far more than mere homage; it stands on it's own as being one of the greatest horror films of all time; and I mean up there with great flicks like "Psycho" and "Dawn of the Dead". And I don't just mean as far as mindless entertainment goes. It really is a magnificently crafted take on the thriller genre. In other words, check it out. It's one of my personal faves.
Check out Jason Wallis' Filmaholics Anonymous web page at http://www.geocities.com/Hollywood/Boulevard/7475
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


CSS Introduction
What is CSS?
CSS
stands for
C
ascading
S
tyle
S
heets
CSS describes
how HTML elements are to be displayed on screen, paper, or in other media
External stylesheets are stored in
CSS files


Before Change
assert top_level_addr.spec == "//:root" == str(top_level_addr) == top_level_addr.reference()
assert top_level_addr.path_safe_spec == ".root"
generated_addr = Address("a/b", relative_file_path="c.txt", target_name="c")
assert generated_addr.spec == "a/b/c.txt:c" == str(generated_addr) == generated_addr.reference()
assert generated_addr.path_safe_spec == "a.b.c.txt.c"
top_level_generated_addr = Address("", relative_file_path="root.txt", target_name="root")
After Change
expected="//root.txt:root",
expected_path_spec=".root.txt.root",
)
assert_spec(
Address("a/b", relative_file_path="subdir/c.txt", target_name="original"),
expected="a/b/subdir/c.txt:../original",
expected_path_spec="a.b.subdir.c.txt@original",
)
assert_spec(
Address("a/b", relative_file_path="c.txt"),
expected="a/b/c.txt",
expected_path_spec="a.b.c.txt",


This is a phonetic keyboard layout for Gujarati. It is based on the ITRANS transliteration scheme by Avinash Chopde, with some minor modifications.


I am currently working as a Software Engineeer at Facebook Inc, London. I have experience in ML and NLP, and was a Blue Scholar Research Software Engineer at IBM Research Labs, India before joining Facebook. I have also worked on Trajectory Pattern Mining during my Masters.
At Facebook, I have worked on interesting problems at scale in the area of Catalog, to name a few, clustering, similarity detection, canonicalisation. I have also worked on large sytems and am currently working on building an experimentation platform at scale. I was also leading hiring for my team and helped in growing our org from 4-50 members
During my time here at IBM Research, I have worked on creating a framework to automatically instantiate a Natural Language Querying engine on any data that the user brings in. I have also had the chance to interface with various clients as a part of this endeavour.
I have also worked on research problems in the Programming by Examples paradigm, where we were looking at the effect of negative examples in learing string transformations.
Developed an android application for Point Data Updation of Geographic Maps using OGC compliant standard GeoSMS. The application has been deployed by the Department of Science and Technology, India, at a National Level, and the pilot deployments at Barnala and New Delhi have been successful.
Extended the GeoSMS framework for Accident Reporting, and built an application which will be used by the Police Officials.
GPA: 9.58
GPA: 8.65
Manasa Jammi, Jaydeep Sen, Ashish Mittal, et al.
Manasa Jammi, Vinay Kolar, Karthik Bharath, Sambit Sahu, Soumya K. Ghosh
Manasa Jammi, Shrutilipi Bhattacharjee, Soumya K. Ghosh and Sudeshna Mitra
Programming Languages
Libraries and Tools
Research
On a lazy sunday afternoon, you will probably see me with a group of 4 other competitive souls sunk in a board game that we have been playing for the past 3 hours. I also like reading, especially fantasy. I am trying my hand at table tennis and football lately.
Website Theme Link - Voila!
P.S. A catch for all my exceptions - link!


You have already changed occupations twice! Go about your business! Why don't you catch a dragon and bring back its scales or pick at a queen ant's corpse?


typealias Decorator = (LogRequest) -> LogRequest
A Decorator can modify any property of a LogRequest, e.g. tag and msg.
Multi decorators are allowed, but you should be aware of the sequence of adding them if they may change same field.
See Also
| AutoTagDecorator |
class AutoTagDecorator : Decorator
Detect and assign a best match log tag for each request. |
| GlobalTagDecorator |
class GlobalTagDecorator : Decorator
Concat a global tag for each single log. |
| LineNumberDecorator |
class LineNumberDecorator : Decorator
Detect and insert line number information into the beginning of log content. |
| ThreadInfoDecorator |
class ThreadInfoDecorator : Decorator
Detect and insert Thread information into the beginning of log content. |


{% extends "cvbapp/base.html" %} {% load static %} {% block addHead %} {% endblock %} {% block content %}
Owner: {{ user_email }}
Description: {{ session_description }}
Submitted: {{ submitted_statement_p2 }}
Please submit your suggested vision statement for this Collaborative Vision Building session.
Step 2 has ended. Please review the submitted vision statements and submit a draft vision statement. Once this is complete, it will be possible to proceed to phase 4.
Submitted: {{ submitted_statement_p3 }}
Step 2 has ended. Vision statements are now being reviewed. Step 4 will begin soon.
Draft Vision Statement:
Please schedule a time for the Vision Statement Draft review.
The meeting will be held at:
{{ submitted_meeting_p4 }}
{% endif %} {% else %} {% if submitted_meeting_p4 == "" %}The owner of this Collaborative Vision Building session is scheduling a time to hold the Vision Statement Draft review meeting.
{% else %}The meeting will be held at:
{{ submitted_meeting_p4 }}
{% endif %} {% endif %}Rocket Chat Link: {{ rc_channel }}
User Count:
Step 4 is done
Step 4 has been completed. Using the discussion from Step 4, finalize a vision statement and produce a report detailing the decisions made.
Submitted: {{ submitted_statement_p5 }}
Remaining Characters: 1024
{% if submitted_report != "" %} {% endif %} {% endif %}Statement
{{ submitted_statement_p5 }}
Report
{{ submitted_report }}
Final Statement
{{ submitted_statement_p5 }}


bool zip_entry_open ( resource $zip , resource $zip_entry [, string $mode ] )
Opens a directory entry in a zip file for reading.
Returns TRUE on success or FALSE on failure. Note: Unlike fopen() and other similar functions, the return value of zip_entry_open() only indicates the result of the operation and is not needed for reading or closing the directory entry.


VIDEO: Bribe-taking Nigerian police officer caught on camera short-changing colleagues
by Cletus UkpongA yet-to-be-identified Nigerian police officer has been caught on camera demanding and collecting bribe from a motorist.
The officer, as seen in the four-minute video, went on to lie to his colleagues about the amount he collected from the motorist.
The video has been shared on Facebook and Twitter.
The date and location where the video was filmed remained unknown as at the time of filing this report.
“Out of the N15,000, if I remove N10,000, how much go come remain? N5,000? No, e no go work?” the man, wearing a police uniform and holding a rifle, is seen in the video arguing with the motorist, using Pidgin English.
“Na wetin wey dey be dat!” the motorist responded, showing no sign he was willing to offer more than N15,000.
The motorist is seen in the video holding out a wad of 1,000 naira notes for the officer who is on the passenger’s seat, besides the driver.
The officer fiddled with a mobile phone and acted as though he was reluctant to collect the bribe. He momentarily placed the phone to his ear, as though he wanted to make a call.
“You know wetin you go do eh?” the officer suddenly asked the man, sounding as if he was concerned and wanted to offer help.
“This man wey I call, him money na N10,000. The N5,000, na him I go come tell my people? Complete that money N20k, so that….”
The motorist cuts in “Oga, I can’t lie for you. Just consider me, please!”
“Me, I don tell you wetin I suppose tell you,” the officer quipped.
The officer at some point in the bargain instructed the motorist to slow down the car, he then began to negotiate a fresh ‘deal’ on how to outsmart his fellow cops who were apparently expecting the bribe.
“This one, it is a secret I am trying to tell you,” he said.
“You will bring N10,000 out of this money, give to that guy. You hear me? For there, you go tell them say na N5,000 you give me.”
The motorist counted N10,000 from the money, gave it to the officer who went on to make a call, apparently to his superior and pleaded with him on behalf of the motorist. He lied in the phone conversation that the motorist gave him N5,000.
“How we go do for this guy, e no even get money!” he said on the phone.


{{ match_key }}
More at The Blue Alliance
Winner:
Total Score:
Auto Score:
Teleop Score:
Endgame Score:
Ranking Points:
Auto High Goal Points:
Auto Low Goal Points:
Teleop High Goal Points:
Teleop Low Goal Points:


po - Patchouli, tool for generating patches from annotated source code.
po
po −C
po −c level
po −b name
po −A level
po −p
Patchouli is a tool for easily creating and maintaining a set of source code patches, while continuing to normally edit, compile, and do version control of the project as one whole.
The basic idea behind Patchouli is that as the source code is modified, the programmer annotates each modification as belonging to a certain patch (see SOURCE CODE ANNOTATIONS below). The programmer can continue to normally view, edit, compile, and run the source code with its embedded annotated modifications. Additionally, the programmer specifies the order of these annotations and can describe them (see CONFIGURATION FILE below).
Then at any point, the entire patch set can be created automatically from these annotations, by running the po tool described in this manual.
Patchouli is especially useful in projects where maintainers expect big changes to be broken down to many small patches, each easier to explain and to review. The programmer would still like to work on the source code as a whole (and not on individual patches), and to be able to easily regenerate the patch set if they need to be resubmitted (e.g., after comments from the maintainer, changes to the base project, and so on).
As explained above, Patchouli uses annotations inserted in the source code which mark modifications, and say which modification belongs to which patch.
The annotations not only mark the modifications, they also need to ensure that the code can be compiled as if all the patches have been applied to it. I.e., lines that are marked as added need to be compiled in, while lines that are marked as deleted need to be ignored. The annotations format shown below indeed satisfies this requirement.
Patchouli
currently supports annotations using C preprocessor
directives. These are useful for C and C++ language code.
The following annotations are supported. In the code
examples below, ordinary text is pre-modification code,
while the bold text is the new source-code lines and their
annotation.
Add lines (in patch named "comment"):
int square(int
n){
#if 1 /* patchouli comment */
/* square n */
#endif
return n*n;
}
Delete lines:
int triple(int
n){
#if 0 /* patchouli remove printouts */
printf("tripling %d0, n);
#endif
return 3*n;
}
Replace lines:
One can replace lines with two separate annotations, marking the deletion of the old lines and then marking the new lines, but a more compact (and natural) representation is available:
int square(int
n){
#if 1 /* patchouli algorithm */
return n*n;
#else
return 2*n;
#endif
}
Or, alternatively,
int square(int
n){
#if 0 /* patchouli algorithm */
return 2*n;
#else
return n*n;
#endif
}
Undone modifications:
In some cases, it is necessary for one patch to make modifications which are later undone (or further modified) by a second patch. This is needed if, for example, the program needs to compile after each individual patch is applied. Such transient modifications can be specified using nested annotations:
#if 0 /*
patchouli patch2 */
#if 1 /* patchouli patch1 */
/* this code is added in patch1, but removed again in patch2
*/
#endif
#endif
Note how the outer annotation describes the later modification: The the line is removed in patch2 and therefore doesn’t exist in the final patched code, so the outer "#if 0" makes sure it isn’t compiled.
As another example, the following annotations replace the function name "try1" in the original code with "try2" in the first patch, and then again renames it to "try3" in the second patch:
#if 0 /*
patchouli second */
#if 0 /* patchouli first */
int try1(){
#else
int try2(){
#endif
#else
int try3(){
#endif
Nested modifications:
Another use for nested annotations is a shortcut for adding new lines in the middle of a block of lines already added by a previous modification. For example, consider we already have a patch adding two lines:
#if 1 /*
patchouli patch1 */
line1
line2
#endif
And now we want to create a second patch, patch2, which adds a new line between these "line1" and "line2". The long way is to split up the original annotation:
#if 1 /*
patchouli patch1 */
line1
#endif
#if 1 /* patchouli patch2 */
added in the middle
#endif
#if 1 /* patchouli patch1 */
line2
#endif
We can use nested annotations for a shorter and perhaps more readable description of the same change:
#if 1 /*
patchouli patch1 */
line1
#if 1 /* patchouli patch2 */
added in the middle
#endif
line2
#endif
Note that currently, po is limited only to a single level of annotation nesting (i.e., the above examples are supported, but deeper level of nesting isn’t).
Modifying C preprocessor directives:
Above we showed the usual way of annotating changes, using C preprocessor directives. Unfortunately, if the change we’re trying to annotate is a single #if, #else, #elif or #endif, we can’t annotate it with our usual annotations. As an example, consider the following ill-attempt to add an "#else" to an existing #if:
#if something
dosomething;
#if 1 /* patchouli patch */
#else
somethingelse;
#endif
#endif
This is wring, because when the compiler reads this code, it wrongly treats the "#else" as referring to the Patchouli annotation, not the "#if something" it was supposed to refer to.
Therefore, for this use-case we have an alternative annotation method, which uses a comment at the end of the line which marks its addition in some patch. The following is the right way to do what we tried to do above:
#if something
dosomething;
#else/***patchouli patch***/
#if 1 /* patchouli patch */
somethingelse;
#endif
#endif
The patch names used in these annotations can be chosen arbitrarily, but they need to be also listed in the PATCHOULI configuration file, as described in the next section. Patch names may include any characters except slash ("/"), newline or null.
In particular, patch names with spaces in them are fine. However, please note that leading or trailing spaces in the patch names are not considered part of the patch name, and are ignored, and in general extraneous white space in annotation lines are ignored. For example, the following lines, with "_" representing a space, all fine, and behave identically:
#if_1_/*_patchouli_name_*/
#if_1_/*__patchouli_name_*/
#if_1_/*_patchouli_name__*/
#if_1_/*_patchouli__name_*/
#if_1_/*patchouli_name*/
#if_1/*_patchouli_name_*/
The source code annotations described above determine which modification goes into which patch file, but to actually create these patch files, the po tool needs additional information, which should be written in a file called "PATCHOULI" in the top directory of the project, where po will be run.
This section lists the various configuration commands available. Specifying at least one patch and at least one file is mandatory,
|
patch |
po needs to know the order of the patches, because patch files refer to specific line numbers and to specific contexts, so the order in which they will be applied matters. |
The order of the patch commands in the PATCHOULI file determines the patch order. Each command specifies a patch name (the name used in the annotations), a one-line description of the patch and an optional long description. The descriptions are used when creating the patch files - the one-line description is used as the subject of the patch file (assuming it will be mailed), and the long description is put after the subject line, and before the actual content of the patch.
A patch command is formatted like this:
patch
name: short description
first line of long description
second line of long description
Each line in the long description must start with a whitespace, because the next line not starting with a whitespace is considered to start a new configuration command. In particular, even a blank line in the long description needs to be a line with a single white space, otherwise it is considered to end the descption.
./PATCHOULI
explain here
0*.patch
explain here
.tmp-patch, .patchouli-level0, .git-*
explain here
Copyright (C) 2010-2013 IBM Corp. Copyright (C) 2013 Nadav Har’El<EMAIL_ADDRESS>Patchouli is based on an original idea proposed by Abel Gordon.
Patchouli is based on original source code written by Nadav Har’El while an IBM employee. This code is copyright (C) 2010-2013 IBM Corp., and is used in Patchouli with permission. However, IBM is not the owner or maintainer of this Patchouli, does not endorse it, or has any other connection with Patchouli. All comments, suggestions, questions or claims regarding Patchouli should be referred to Nadav Har’El directly.
Patchouli is free software, released under the Apache License v2. There is no warranty of any kind.
diff(1), patch(1), git(1), cpp(1)


See: Description
| Interface | Description |
|---|---|
| AbstractHeaderMapper.HeaderMatcher |
Strategy interface to determine if a given header name matches.
|
| BytesMessageMapper | |
| HeaderMapper<T> |
Generic strategy interface for mapping
MessageHeaders to and from other
types of objects. |
| InboundMessageMapper<T> |
Strategy interface for mapping from an Object to a
Message . |
| OutboundMessageMapper<T> |
Strategy interface for mapping from a
Message to an Object. |
| RequestReplyHeaderMapper<T> |
Request/Reply strategy interface for mapping
MessageHeaders to and from other
types of objects. |
| Class | Description |
|---|---|
| AbstractHeaderMapper<T> |
Abstract base class for
RequestReplyHeaderMapper implementations. |
| AbstractHeaderMapper.CompositeHeaderMatcher |
A composite
AbstractHeaderMapper.HeaderMatcher that matches if one of provided
AbstractHeaderMapper.HeaderMatcher s matches to the headerName . |
| AbstractHeaderMapper.ContentBasedHeaderMatcher |
A content-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header is contained within a list of candidates. |
| AbstractHeaderMapper.PatternBasedHeaderMatcher |
A pattern-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header matches one of the specified simple patterns. |
| AbstractHeaderMapper.PrefixBasedMatcher |
A prefix-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header starts with a configurable prefix. |
| AbstractHeaderMapper.SinglePatternBasedHeaderMatcher |
A pattern-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header matches the specified simple pattern. |
| Exception | Description |
|---|---|
| MessageMappingException |
Exception that indicates an error during message mapping.
|


The Spry Checkbox Validation Widget is used to validate a checkbox or series of checkboxes before submitting the form.
The widget structure is as follows:
<widget container> <input checkbox(es)>
<message container>
</widget container>
The Checkbox Validation Widget supports one or many checkboxes.
The markup used in this structure can be most any HTML, as long as it follows the rules for nesting.
Using the provided files, the default mark up is:

<input type="checkbox" name="checkbox1" id="checkbox1" />
Please make a selection.
Widget Constructors are small pieces of javascript that activate the markup into the working widget. These scripts must come AFTER the markup on the page, since the markup needs to exist before the constructor fires.

A basic constructor specifies the name of the widget and identifies the ID of the main markup container. The name of the widget is used to identify the widget for functions and methods.

Constructor options allow users to specify certain attributes of the widget.
Constructor options follow the ID parameter, wrapped in curly braces {}. Options are name:value pairs, separated by a colon (:).

| Option | Values | Default | Description |
|---|---|---|---|
| isRequired | true or false | true | Determines whether any checkboxes need to be checked. Set to 'false' to bypass validation. |
| maxSelections | number | null | Determines the maximum number of checkboxes that can be checked within the checkbox group. |
| minSelections | number | null | Determines the minimum number of checkboxes that need to be checked before being valid. |
| validateOn | "blur", "change" | submit | The widget always validates onSubmit. onBlur and onChange can be added with this option. Both can be applied with an array ['blur', 'change'] |

Recall that javascript is case sensitive.
Reset the widget to its original state.
widgetName.reset();
Reset Checkbox
Validates the current state of the widget.
widgetName.validate();
Validate Checkbox
Copyright © 2007. Adobe Systems Incorporated.
All rights reserved.


--- layout: post title: DependencyProperty inheritance doesn't cross the UserControl boundary! date: '2006-12-20T23:15:00.001Z' tags: [wpf] modified_time: '2006-12-20T23:15:17.973Z' blogger_id: tag:blogger.com,1999:blog-4015568221071268916.post-6637733387721193088 comments: true blogger_orig_url: http://serialseb.blogspot.com/2006/12/dependencyproperty-inheritance-doesn.html ---
Still got lot of work to do tonight but more on that tomorrow.


Posted by Dean+Golden on July 8, 2019
This is a question that students, parents, teachers, and guidance counselors try to tackle each year. Junior year was once an ideal time, but as high school courses become more challenging and extracurriculars become more plentiful (because college applications are right around the corner), students are becoming more and more stressed by the idea of including SAT/ACT preparation work into their already full lives. In order to alleviate this stress, Dean+Golden Education suggests that parents have their students answer these three questions to determine when and how to officially begin preparing for those pesky college admissions exams.
In the middle of football season for a football player or while preparing for a major production as the lead actor or actress are likely to be times when one shouldn’t also prepare for standardized testing. Students should strive to work towards SAT/ACT preparation during athletic off-seasons, long holiday breaks (summer and winter), and/or when there’s enough time to dedicate several hours per week to uninterrupted study and practice. Students should also consider when they have other major tests; preparing for the SAT/ACT while also preparing for AP exams or End of Course exams may not be the best time.
A mock test is the easiest way to determine what to study and how much time to dedicate to studying. You can find sample questions and full-length tests for both the SAT and ACT online:
SAT Sample Tests | ACT Sample Tests
When practicing problems or taking a mock test, it is a best practice to mimic the testing environment: a quiet or silent room with no distractions. After practicing problems or completing a mock test, scoring and interpreting the score is crucial. If assistance is needed at this step, we can proctor a mock test, interpret results for your student, and advise on the next steps.
This is a question that most people forget to ask when preparing to engage in test prep. While it is best practice to try to achieve the highest score possible, it may be more efficient to determine the best scoring range for a student’s intended college list. Most universities will publish the average score for its most recent incoming class (example: Tulane Class of 2023 profile). Students can use this information to determine the score that they need.
At Dean+Golden Education, we honor and celebrate the different learning styles and abilities of all students. Some students only need to be pointed in the right direction to free resources such as Khan Academy that provide online support for SAT. In addition, there are many SAT and ACT books for purchase online at Amazon.com or at any major book store. These books usually include some sort of study plan that students can use.
Some students may require someone to work with them one-on-one or in a group to explain topics and concepts along the way. In addition, a tutor can assign targeted homework problems and remain in communication with parents about progress. This option provides the student and their family with continuous support throughout their preparation.
If you’re interested in learning more about one-on-one or group tutoring with Dean+Golden Education, we’d be more than happy to talk more with you about the options that we offer.


Dhananjay Mahapatral, reporting for The Times of India:
…the Supreme Court collegium has finalised the memorandum of procedure (MoP) for appointment of judges to constitutional courts.
Finally.
The appointment of Supreme Court judges was a heavily debated topic under previous Chief Justice T. S. Thakur, starting with the Centre’s suggestion for a National Judicial Appointments Commission (NJAC), which was struck down by the Supreme Court in October 2015.
In December 2015, a Constitutional Bench of the Supreme Court ruled that the Central Government could amend the Memorandum of Procedure for appointment of judges, in consultation with the CJI. The Bench also broadly suggested that amendments towards eligibility of judges, transparency in appointments and establishment of a secretariat to review appointment-related complaints be looked into.
A bone of contention related to the ‘national security’ clause that the Centre insisted on adding to the eligibility of judges for appointment, and the Secretariat. Progress has been swift since Chief Justice J. S. Khehar took over in January, and the new Collegium has now approved both items.
Further:
Finalisation of the MoP, which will be sent to the Centre for approval and adoption this week, raises hopes of speedy filling up of vacancies in HCs, which are operating at below 60% of their sanctioned strength.
Clearance of pending cases is a huge problem in India. Just last week, the Supreme Court also set out timelines for case hearing, ordering lower courts to dispense of cases more than five years’ old by the end of the year.


|
Linear Model Measures
|
|
| The standard linear
models for stationary time series are the autoregressive (AR) models and
the autoregressive moving average (ARMA) models. Here these models are
implemented in order to derive statistical measures of fitting and prediction for
varying model orders and prediction steps. The difference between the fitting
and prediction measures is in the set of samples that are used to
compute the statistical measure: all the samples are used for fitting and the
samples in the so-called test set for prediction. Here, the test set is the last
part of the time series. For multi-step fit or prediction the iterative
scheme is used and the one step predictions from previous steps are used
to make predictions for the current step.
Four standard statistical measures are encountered, the mean square error (MSE), the normalized mean square error (NMSE), the normalized root mean square error (NMSE) and the correlation coefficient (CC). The three last measures account for the variance of the time series and this allows comparison of the measure across different time series. AR and ARMA models are basic tools of linear analysis of time series and statistical description for them (estimation, inference, predictions) can be found in any standard book on time series analysis, e.g. see Box G.E.P., Jenkins G.M., and Reinsel G.C. (1994), Time Series Analysis: Forecasting and Control, Prentice-Hall, Third Edition, New Jersey. |
|
| Autoregressive Fit (AR_____Fit) |
|
|
Autoregressive Fit gives four statistical measures of goodness of fit
with autoregressive (AR) model. A number of different orders for the
AR model can be given and the fit can be computed for a number of lead
times. The following parameters can be specified: - model order (m) : any valid matlab format denoting an array of positive integers or a single positive integer. The default is '1' meaning that the computations of the goodness of fit measures will be done for the simplest model AR(1). - prediction time (h) : any valid matlab format denoting an array of positive integers or a single positive integer. The default is '1' meaning that the computations of the goodness of fit measures will be done only for one-step ahead. The user can activate (check) any of the four statistical measures to save results for. If none is checked then results for all four measures will be computed and the measures will be included in the measure list. The statistical measures are the following: - MSE : if checked the mean square error (MSE) measure of goodness of fit for the specified model orders and prediction times will be included in the list of measures. MSE is the sum of squares of prediction errors defined as
where xi+h is the actual sample and xi(h) is the h-step ahead prediction at current time i, for i=m,...,N-h, and N is the length of the time series. - NMSE : if checked the normalized mean square error (MSE) measure of goodness of fit for the specified model orders and prediction times will be included in the list of measures. NMSE is the MSE divided by the variance of the samples included in the sum of MSE, defined as
where is the mean of the samples in the sum. - NRMSE : if checked the normalized root mean square error (MSE) measure of goodness of fit for the specified model orders and prediction times will be included in the list of measures. NRMSE is the square root of NMSE. - CC : if checked the correlation coefficient (CC) measure of goodness of fit for the specified model orders and prediction times will be included in the list of measures. CC is the standard Pearson correlation coefficient between the actual samples and the respective predictions, i.e. xi+h and xi(h) for h-step ahead prediction at current time i. Example: If the user selects this measure by activating the check box in the beginning of the measure line and sets for model order (m) '5 10' and for prediction time (h) '1:4', and checks only NRMSE then the NRMSE measure of Autoregressive Fit is computed for the combinations of the 2 values of m and the 4 values of h and in the measure list the following measure names will appear AR_____FitNRMSEm5h1 |
|
| Autoregressive Prediction (AR_Predict) |
|
|
Autoregressive Prediction gives four statistical measures for the
prediction error with autoregressive (AR) model. The AR model is
estimated in the first part of the time series, the so-called training set,
and the predictions are made in the second part of the time series,
the so-called test set. A parameter can be specified to determine the size
of the test set. A number of different orders for the AR model can be
given and the predictions can be computed for a number of lead times.
The following parameters can be specified: - fraction for test set (f) : any number between 0.1 and 0.9. The default is '0.5' meaning that the test set is the second half of the time series. Typically f should be smaller or equal to 0.5, so that the test set does not exceed in size the training set. - model order (m) : any valid matlab format denoting an array of positive integers or a single positive integer. The default is '1' meaning that the computations of the goodness of fit (prediction here) measures will be done for the simplest model AR(1). - prediction time (h) : any valid matlab format denoting an array of positive integers or a single positive integer. The default is '1' meaning that the computations of the goodness of fit (prediction here) measures will be done only for one-step ahead. The user can activate (check) any of the four statistical measures to save results for. If none is checked then results for all four measures will be saved and the measures will be included in the measure list. The statistical measures are the following: - MSE : if checked the mean square error (MSE) measure of prediction in the test set for the specified model orders and prediction times will be included in the list of measures. MSE is the sum of squares of prediction errors defined as
where xi+h is the actual sample and xi(h) is the h-step ahead prediction at current time i, for i=N1,...,N-h, N is the length of the time series and N1 is the length of the training set ( N1 = (1-f)N ). - NMSE : if checked the normalized mean square error (MSE) measure of prediction in the test set for the specified model orders and prediction times will be included in the list of measures. NMSE is the MSE divided by the variance of the samples included in the sum of MSE, defined as
where is the mean of the samples in the sum - NRMSE : if checked the normalized root mean square error (MSE) measure of prediction in the test set for the specified model orders and prediction times will be included in the list of measures. NRMSE is the square root of NMSE. - CC : if checked the correlation coefficient (CC) measure of prediction in the test set for the specified model orders and prediction times will be included in the list of measures. CC is the standard Pearson correlation coefficient between the actual samples and the respective predictions. Example: If the user selects this measure by activating the check box in the beginning of the measure line and sets for fraction for test set (f) '0.25', model order (m) '5 10' and for prediction time (h) '1:4', and checks only NRMSE then the NRMSE measure of Autoregressive Prediction is computed on a test set of length one forth of time series length for the combinations of the 2 values of m and the 4 values of h and in the measure list the following measure names will appear (note that the value for f in the measure names is multiplied by 100, and rounded)
AR_PredictNRMSEf25m5h1 |
|
| Autoregressive Moving Average Fit (ARMA___Fit) |
|
|
Autoregressive Moving Average Fit gives four statistical measures of goodness of fit
with autoregressive moving average (ARMA) model. A number of different orders for the
AR part and the MA part of the model can be given and the fit can be computed for a number of lead
times. The following parameters can be specified: - AR order (m) : any valid matlab format denoting an array of positive integers or a single positive integer. The default is '1' meaning that the computations of the goodness of fit measures will be done for the ARMA model with AR part of order 1. - MA order (p) : any valid matlab format denoting an array of positive integers or a single positive integer. The default is '1' meaning that the computations of the goodness of fit measures will be done for the ARMA model with MA part of order 1. - prediction time (h) : any valid matlab format denoting an array of positive integers or a single positive integer. The default is '1' meaning that the computations of the goodness of fit measures will be done only for one-step ahead. The user can activate (check) any of the four statistical measures to save results for. If none is checked then results for all four measures will be computed and the measures will be included in the measure list. The statistical measures are the following: - MSE : if checked the mean square error (MSE) measure of goodness of fit for the specified model orders and prediction times will be included in the list of measures. MSE is the sum of squares of prediction errors defined as
where xi+h is the actual sample and xi(h) is the h-step ahead prediction at current time i, for i=m,...,N-h, and N is the length of the time series. - NMSE : if checked the normalized mean square error (MSE) measure of goodness of fit for the specified model orders and prediction times will be included in the list of measures. NMSE is the MSE divided by the variance of the samples included in the sum of MSE, defined as
where is the mean of the samples in the sum. - NRMSE : if checked the normalized root mean square error (MSE) measure of goodness of fit for the specified model orders and prediction times will be included in the list of measures. NRMSE is the square root of NMSE. - CC : if checked the correlation coefficient (CC) measure of goodness of fit for the specified model orders and prediction times will be included in the list of measures. CC is the standard Pearson correlation coefficient between the actual samples and the respective predictions, i.e. xi+h and xi(h) for h-step ahead prediction at current time i. Example: If the user selects this measure by activating the check box in the beginning of the measure line and sets for order of the AR part (m) '5 10', the order for the MA part (p) '1' and for prediction time (h) '1:4', and checks only NRMSE then the NRMSE measure of Autoregressive Moving Average Fit is computed for the combinations of the 2 values of m, and the 4 values of h (p has only one value here) and in the measure list the following measure names will appear ARMA___FitNRMSEm5p1h1 |
|
| Autoregressive Moving Average Prediction (ARMAPredic) |
|
|
Autoregressive Moving Average Prediction gives four statistical measures for the
prediction error with autoregressive moving average (ARMA) model. The ARMA model is
estimated in the first part of the time series, the so-called training set,
and the predictions are made in the second part of the time series,
the so-called test set. A parameter can be specified to determine the size
of the test set. A number of different orders for the AR part and the MA
part of the model can be
given and the predictions can be computed for a number of lead times.
The following parameters can be specified: - fraction for test set (f) : any number between 0.1 and 0.9. The default is '0.5' meaning that the test set is the second half of the time series. Typically f should be smaller or equal to 0.5, so that the test set does not exceed in size the training set. - AR order (m) : any valid matlab format denoting an array of positive integers or a single positive integer. The default is '1' meaning that the computations of the goodness of fit (prediction here) measures will be done for the ARMA model with AR part of order 1. - MA order (p) : any valid matlab format denoting an array of positive integers or a single positive integer. The default is '1' meaning that the computations of the goodness of fit (prediction here) measures will be done for the ARMA model with MA part of order 1. - prediction time (h) : any valid matlab format denoting an array of positive integers or a single positive integer. The default is '1' meaning that the computations of the goodness of fit (prediction here) measures will be done only for one-step ahead. The user can activate (check) any of the four statistical measures to save results for. If none is checked then results for all four measures will be saved and the measures will be included in the measure list. The statistical measures are the following: - MSE : if checked the mean square error (MSE) measure of prediction in the test set for the specified model orders and prediction times will be included in the list of measures. MSE is the sum of squares of prediction errors defined as
where xi+h is the actual sample and xi(h) is the h-step ahead prediction at current time i, for i=N1,...,N-h, N is the length of the time series and N1 is the length of the training set ( N1 = (1-f)N ). - NMSE : if checked the normalized mean square error (MSE) measure of prediction in the test set for the specified model orders and prediction times will be included in the list of measures. NMSE is the MSE divided by the variance of the samples included in the sum of MSE, defined as
where is the mean of the samples in the sum - NRMSE : if checked the normalized root mean square error (MSE) measure of prediction in the test set for the specified model orders and prediction times will be included in the list of measures. NRMSE is the square root of NMSE. - CC : if checked the correlation coefficient (CC) measure of prediction in the test set for the specified model orders and prediction times will be included in the list of measures. CC is the standard Pearson correlation coefficient between the actual samples and the respective predictions. Example: If the user selects this measure by activating the check box in the beginning of the measure line and sets for fraction for test set (f) '0.25', for the order of the AR part (m) '5 10', for the order for the MA part (p) '1', and for prediction time (h) '1:4', and checks only NRMSE then the NRMSE measure of Autoregressive Moving Average Prediction is computed on a test set of length one forth of time series length for the combinations of the 2 values of m and the 4 values of h (p has only one value here) and in the measure list the following measure names will appear (note that the value for f in the measure names is multiplied by 100, and rounded)
ARMAPredicNRMSEf25m5p1h1 |
|
| OK |
|
| By pressing this button the window of "Linear Model Measures" will disappear and the user will be moved to the "Select / run measures" window. Any changes in the measures and parameter values will be stored. | |
| Cancel |
|
| Quit without doing anything and return to the "Select / run measures" window. Any changes in the measures and parameter values will be ignored. | |
| Help |
|
| This file will be shown. |


{% extends 'base.html' %} {% block title%}About{% endblock %} {% block content %}
Paste IT is a private paste bin service. It is an open source (MIT license) project and can be found at GitHub. Feel free to contribute, report bugs or give feedback.
There are a lot of paste bins on the internet but none suited my idea of having a plain, clean, fast and most importantly secure paste bin. And as an Linux user I need and want to paste and grep via command line.  So an API was needed as well.
Paste It uses Python, Django and Pygments.


Coffee
The only hope for making a world peace
Learn about the magic
He actually has coffee every morning


-
Zenefits’ Leader Is Rattling an Industry, So Why Is He Stressed Out? - ...
www.nytimes.com
Parker Conrad’s start-up, Zenefits, is thought to be one of the fastest-growing companies in recent Silicon Valley history, and his investors and ...
-
UberMILITARY: We Want You | Uber Blog
blog.uber.com
Transitioning from military to civilian life can be challenging, but at Uber we understand that veterans are some of our nation’s most talented and ...
-
The 50 Best Public Relations People In The Tech Industry In 2014
www.businessinsider.com
Our annual shout-out to the PR pros who go above and beyond to help tech journalists.
-
Testing a way for you to make purchases on Twitter | Twitter Blogs
blog.twitter.com
A new way to discover and buy products on Twitter.
-
Rise | Personal Nutrition Coaching
www.rise.us
Rise connects you directly to a private nutritionist through your mobile device.
-
How to Start a Startup
startupclass.samaltman.com
CS183B is a class we’re teaching at Stanford. It’s designed to be a sort of one-class business course for people who want to start startups.
-
Burn Baby Burn – AVC
avc.com
Andy sent me a WSJ piece with Bill Gurley yesterday. I don’t like to link to paid content so here’s a good Business Insider summary of the article ...
-
Googler Megan Smith’s White House job: Basically a done deal
fortune.com
White House will strengthen ties to Google with new CTO pick.
-
WhatsApp Used This Pricing Strategy to Win and You Can Too
firstround.com
Seven years ago, First Round Partner Josh Kopelman wrote a seminal blog post on the importance of free services in consumer-facing business models. ...
-
E La Carte Raises $35 Million to Expand Pay-at-the-Table Technology
blogs.wsj.com
The startup's technology lets restaurant-goers order food and pay their bills from the table.
-
These apps WILL change your life.
www.refinery29.com
One of the perks of living in San Francisco is finding out about the most interesting apps before they go mainstream. Yeah, that’s right — we joined ...
-
Meet Blue Bottle at Home
www.youtube.com
Here’s a preview of Blue Bottle at Home, a newly branded e-commerce destination and coffee subscription service for customers. CEO and founder James ...
-
There’s a Dragon at the Door – Redpoint Ventures
www.redpoint.com
All eyes are focused this week on Alibaba. The Chinese-based ecommerce powerhouse will make its debut as the largest technology initial public ...
-
This Is How You Get People to Trust Your Product
firstround.com
Most new tech companies simply would not work without consumer trust. People wouldn’t get into an Uber, list their home on Airbnb, or even buy shoes ...
-
Why I Started to Hate ‘Leaning In’
medium.com
I woke up on a Saturday about a year ago so tired that I couldn’t get out of bed. I’d just worked a 70+ hour week, taken…
-
6 Apps To Download While You Wait For The iPhone 6
www.refinery29.com
Sapphire, iWatch, HealthKit, NFC, iOS 8 — the excitement is palpable. Out here in the technosphere, everyone is getting giddy thinking about what new ...
-
“The Burned-Out Blogger’s Guide To PR” Is Amazing, Hilarious And Mostly ...
techcrunch.com
More than anything else, Jason Kincaid’s new book The Burned-Out Blogger's Guide To PR is about the startup journey. It has something for everyone, ...
-
The Shift by Tory Johnson - #1 Best Seller now in Paperback
shiftwithtory.com
You CAN do this. Tory Johnson’s #1 bestselling, inspirational journey to a healthier and happier life – available in paperback with new and exclusive ...
-
Patience is a Virtue! - VentureBlog
hornik.typepad.com
My grandmother used to tell me, my brother and sister that “patience is a virtue.” Of course, she used to say it while we were playing gin rummy and ...
-
Eric Newcomer (Ft. Eric Vishria, Justin Kan & Sam Altman) – Venture Firms ...
tech.genius.com
The Information wrote about Y Combinator today. I didn’t agree with all of it, and I wanted to point out some of the major disagreements. ...
-
Employee Onboarding at Startups Is Broken – Here’s How to Fix It
firstround.com
You’re greeted at the pearly gates to heaven by St. Peter who asks where you’d like to spend eternity. “Well, heaven of course!” you say. Peter ...
-
The Dropbox Blog – Introducing a more powerful Dropbox Pro
blog.dropbox.com
Dropbox lets you bring your photos, docs, and videos anywhere and share them easily. Never email yourself a file again!
-
Hyperlapse, Instagram's New App, Is Like a $15,000 Video Setup in Your ...
www.wired.com
Today, Instagram is lifting the veil on Hyperlapse, the company's first-ever app outside of Instagram itself.
-
This Robot Butler Tried To Get Me Drunk | TechCrunch
techcrunch.com
The merry TechCrunch band took a trip to Cupertino this week to kick it with a small robot called Botlr made by robotics startup Savioke. The little..


The algorithm/transform.h
header defines an algorithm that transforms the elements of a generic data structure with a user-specified operation.
#include <chaos/preprocessor/algorithm/transform.h>
The CHAOS_PP_TRANSFORM
macro transforms each element of its second argument with the operation specified by its first argument.
CHAOS_PP_EXPR
(CHAOS_PP_TRANSFORM
(op, g))
The operation to be used to transform each element of g. This operation must be either a λ expression or a macro name that refers to a macro with a signature compatible with the following pseudo-signature:
op(s, elem†)
†
If the type of g is non-variadic, elem must be ...
or the number of parameters that corresponds to the number of sub-elements in each element of g.
Otherwise, elem must be ...
or a single parameter.
The generic data structure whose elements are to be transformed.
CHAOS_PP_EXPR
(CHAOS_PP_TRANSFORM
(op, g, ...))
The operation to be used to transform each element of g. This operation must be either a λ expression or a macro name that refers to a macro with a signature compatible with the following pseudo-signature:
op(s, elem†, data‡)
† If the type of g is non-variadic, elem must be the number of parameters that corresponds to the number of sub-elements in each element of g. Otherwise, elem must be a single parameter.
‡
The data pseudo-parameter must be either ...
or the number of parameters that corresponds to the number of arguments in the auxiliary data, __VA_ARGS__
.
The generic data structure whose elements are to be transformed.
Auxiliary data to be passed through the algorithm to the operation.
CHAOS_PP_EXPR
(CHAOS_PP_TRANSFORM
(op, g, data))
The operation to be used to transform each element of g. This operation must be a macro name that refers to a macro with a signature compatible with the following pseudo-signature:
op(s, elem, data)
The generic data structure whose elements are to be transformed.
Auxiliary data to be passed through the algorithm to the operation.
The CHAOS_PP_TRANSFORM
macro itself expands to a deferred expression in terms of
.
This deferred expression, when invoked by CHAOS_PP_NEXT
(s)CHAOS_PP_EXPR
, expands to a generic data structure of the same type as g that contains the transformed elements of g.
The operation is invoked with the current recursion state (s), a particular element (elem), and, if it exists, the auxiliary data (data or __VA_ARGS__
).
This invocation must expand to an element that replaces the element for which it is invoked or a deferred expression in terms of
that expands to such an element.
Expansion to a deferred expression allows the operation to recurse on itself if necessary.
CHAOS_PP_NEXT
(s)
In C99, it is possible to omit the auxiliary data argument altogether. This is different than passing "nothing" as the auxiliary data.
#define D (CHAOS_PP_TUPLE
) (a, b, c)CHAOS_PP_EXPR
(CHAOS_PP_TRANSFORM
(OP, D,) // #1CHAOS_PP_TRANSFORM
(OP, D) // #2 )
The first line passes "nothing" as the auxiliary data, which causes OP
to be invoked as (e.g.)...
OP(s, a,)
The second line omits the auxiliary data, which causes OP
to be invoked as (e.g.)...
OP(s, a)
The fundamental difference is that, in the first line, the auxiliary data is empty (which might have a valid meaning as data), but, in the second line, there is no auxiliary data. Hence, the algorithm is overloaded on a true-optional parameter.
Invocations of the operation are trampolined such that each invocation is invoked with
, where s is the original recursion state at the beginning of the algorithm (i.e. CHAOS_PP_NEXT
(s)
).
This maximizes the utility of the recursion backend.
CHAOS_PP_STATE
()
Ignoring the complexity of op (which is invoked once for each element in g), the efficiency of the algorithm's use of the recursion backend can be described in terms of the number of recursion steps required to complete the algorithm. The asymptotic upper and lower bounds are Θ(n+1), where n is the number of elements in g.
This macro deduces the current recursion state and invokes CHAOS_PP_TRANSFORM_S
.
If the the current recursion state is already known, direct use of CHAOS_PP_TRANSFORM_S
is more efficient.
This macro may not be used if bypass semantics are in effect.
CHAOS_PP_AUTO_TRANSFORM
CHAOS_PP_SEQ_AUTO_TRANSFORM
CHAOS_PP_SEQ_TRANSFORM
CHAOS_PP_TRANSFORM_X
CHAOS_PP_TUPLE_AUTO_TRANSFORM
CHAOS_PP_TUPLE_TRANSFORM
CHAOS_PP_VARIADIC_SEQ_AUTO_TRANSFORM
CHAOS_PP_VARIADIC_SEQ_TRANSFORM
#include<chaos/preprocessor/algorithm/transform.h>
#include<chaos/preprocessor/config.h>
#include<chaos/preprocessor/control/if.h>
#include<chaos/preprocessor/lambda/ops.h>
#include<chaos/preprocessor/list/core.h>
#include<chaos/preprocessor/recursion/expr.h>
#define OP(s, elem, data)CHAOS_PP_IF
(elem)(elem, data)CHAOS_PP_EXPR
(CHAOS_PP_TRANSFORM
( OP, (CHAOS_PP_LIST
) (1, (0, (0, (5, ...)))), ~ )) // (CHAOS_PP_LIST
) (1, (~, (~, (5, ...)))) #ifCHAOS_PP_VARIADICS
??=includeCHAOS_PP_PLACEHOLDERS
(1)CHAOS_PP_EXPR
(CHAOS_PP_TRANSFORM
(CHAOS_PP_IF_
(_1)(_1, ~), (CHAOS_PP_LIST
) (1, (0, (0, (5, ...)))) )) // (CHAOS_PP_LIST
) (1, (~, (~, (5, ...)))) ??=includeCHAOS_PP_PLACEHOLDERS
(0) #endif
The CHAOS_PP_TRANSFORM_ID
macro indirectly expands to CHAOS_PP_TRANSFORM
.
CHAOS_PP_TRANSFORM_ID
()
This macro effectively allows CHAOS_PP_TRANSFORM
to pass through itself without becoming disabled.
The CHAOS_PP_TRANSFORM_
macro expands to a λ expression representing CHAOS_PP_TRANSFORM
.
CHAOS_PP_TRANSFORM_
This macro is a shorthand form of the following λ binding:
The CHAOS_PP_TRANSFORM_S
macro behaves identically to CHAOS_PP_TRANSFORM
except that it is parametized by the recursion state.
CHAOS_PP_EXPR_S
(s)(CHAOS_PP_TRANSFORM_S
(s, op, g))
The current recursion state.
The operation to be used to transform each element of g. This operation must be either a λ expression or a macro name that refers to a macro with a signature compatible with the following pseudo-signature:
op(s, elem†)
†
If the type of g is non-variadic, elem must be ...
or the number of parameters that corresponds to the number of sub-elements in each element of g.
Otherwise, elem must be ...
or a single parameter.
The generic data structure whose elements are to be transformed.
CHAOS_PP_EXPR_S
(s)(CHAOS_PP_TRANSFORM_S
(s, op, g, ...))
The current recursion state.
The operation to be used to transform each element of g. This operation must be either a λ expression or a macro name that refers to a macro with a signature compatible with the following pseudo-signature:
op(s, elem†, data‡)
† If the type of g is non-variadic, elem must be the number of parameters that corresponds to the number of sub-elements in each element of g. Otherwise, elem must be a single parameter.
‡
The data pseudo-parameter must be either ...
or the number of parameters that corresponds to the number of arguments in the auxiliary data, __VA_ARGS__
.
The generic data structure whose elements are to be transformed.
Auxiliary data to be passed through the algorithm to the operation.
CHAOS_PP_EXPR_S
(s)(CHAOS_PP_TRANSFORM_S
(s, op, g, data))
The current recursion state.
The operation to be used to transform each element of g. This operation must be a macro name that refers to a macro with a signature compatible with the following pseudo-signature:
op(s, elem, data)
The generic data structure whose elements are to be transformed.
Auxiliary data to be passed through the algorithm to the operation.
This macro may not be used if bypass semantics are in effect.
#include<chaos/preprocessor/algorithm/transform.h>
#include<chaos/preprocessor/config.h>
#include<chaos/preprocessor/control/iif.h>
#include<chaos/preprocessor/detection/is_variadic.h>
#include<chaos/preprocessor/generics/strip.h>
#include<chaos/preprocessor/lambda/ops.h>
#include<chaos/preprocessor/logical/compl.h>
#include<chaos/preprocessor/recursion/basic.h>
#include<chaos/preprocessor/recursion/expr.h>
#include<chaos/preprocessor/tuple/core.h>
#ifCHAOS_PP_VARIADICS
#define OP(s, elem) \ OP_I(CHAOS_PP_OBSTRUCT
(),CHAOS_PP_NEXT
(s), elem) \ /**/ #define OP_I(_, s, elem) \CHAOS_PP_IIF
_(CHAOS_PP_IS_VARIADIC
(elem))( \CHAOS_PP_STRIP
_( \CHAOS_PP_EXPR_S
(s) _(CHAOS_PP_TRANSFORM_S
_( \ s, OP_INDIRECT _(), (CHAOS_PP_TUPLE
) elem \ )) \ ), \CHAOS_PP_COMPL
_(elem) \ ) \ /**/ #define OP_INDIRECT() OPCHAOS_PP_EXPR
(CHAOS_PP_TRANSFORM
( OP, (CHAOS_PP_TUPLE
) (0, 1, (0, 1, 0, 1), ((0, (1, 0), 1), 0, 1)) )) // (CHAOS_PP_TUPLE
) // (1, 0, (1, 0, 1, 0), ((1, (0, 1), 0), 1, 0)) ??=includeCHAOS_PP_PLACEHOLDERS
(1)CHAOS_PP_EXPR
(CHAOS_PP_TRANSFORM
(CHAOS_PP_IIF_
(CHAOS_PP_IS_VARIADIC_
(_1))(CHAOS_PP_STRIP_
(CHAOS_PP_EXPR_S_
(_0)(CHAOS_PP_TRANSFORM_S_
( _0,CHAOS_PP_SELF
(), (CHAOS_PP_TUPLE
) _1 )) ),CHAOS_PP_COMPL_
(_1) ), (CHAOS_PP_TUPLE
) (0, 1, (0, 1, 0, 1), ((0, (1, 0), 1), 0, 1)) )) // (CHAOS_PP_TUPLE
) // (1, 0, (1, 0, 1, 0), ((1, (0, 1), 0), 1, 0)) ??=includeCHAOS_PP_PLACEHOLDERS
(0) #endif
The CHAOS_PP_TRANSFORM_S_ID
macro indirectly expands to CHAOS_PP_TRANSFORM_S
.
CHAOS_PP_TRANSFORM_S_ID
()
This macro effectively allows CHAOS_PP_TRANSFORM_S
to pass through itself without becoming disabled.
The CHAOS_PP_TRANSFORM_S_
macro expands to a λ expression representing CHAOS_PP_TRANSFORM_S
.
CHAOS_PP_TRANSFORM_S_
This macro is a shorthand form of the following λ binding:


EVENT PLANNING
Profile
To Do List
My Budget
Wishlist
To Do List
Create New Task
Task Title
Task Date
Task Deskription
SAVE TASK
January 2020
May 2020
March 2020


--- layout: page title: Lean Prover Zulip Chat Archive permalink: archive/113488general/61377importeverything.html ---
should / do we have a test file that imports every file?
Why?
to test for conflict?
You mean declarations with the same name?
right
This is what
- lean --recursive --export=mathlib.txt src/ - leanchecker mathlib.txt
accomplishes
oh, neat
Travis does it every time and you can get git to check it when you commit or push a branch
Or, if you know how to build a VS Code feature, you can create a command to run exactly that
{% endraw %}


Note
This tutorial was generated from a Jupyter notebook that can be downloaded here.
Time evolution of starry
maps¶
Warning
This tutorial showcases some experimental features. Modeling time evolution in starry
is
still quite clunky and inefficient. It is also extremely difficult! Whatever degeneracies
we have in the static case (there are tons!) are made even worse by the fact that we now have
many more degrees of freedom. Unless we have really good priors, it is very difficult to get meaningful
results out of time-variable maps. We’re working on ways to make this easier, faster, and more
tractable, so please stay tuned.
In this notebook, we’re going to take a look at how to model a star whose light curve evolves in time. The assumption here is that the evolution is due to either spot migration / evolution or differential rotation, so we need a way to model a time-variable surface map. There’s a few different ways we can do that. Please note that these are all experimental features – we’re still working on the most efficient way of modeling temporal variability, so stay tuned!
Let’s begin with our usual imports.
[3]:
import matplotlib.pyplot as plt
import numpy as np
from tqdm.notebook import tqdm
from scipy.special import factorial
import starry
starry.config.lazy = False
starry.config.quiet = True
Generate the data¶
Let’s generate a map with three discrete Gaussian spots at different latitudes, rotating at slightly different rates due to a differential rotation with small shear \(\alpha = 0.02\). To create this dataset, we are linearly combining the flux generated from three separate maps and median-normalizing the light curve at the end.
We’re giving the map an inclination of 60 degrees and some limb darkening. These choices reduce the size of the null space slightly, making it easier to do inference. (Note that we are cheating since we assume below that we know the inclination and limb darkening exactly!)
[4]:
inc = 60 # inclination
u1 = 0.5 # linear limb darkening coeff
alpha = 0.02 # differential rotation shear
P = 1.0 # equatorial period
intensity = -0.5 # spot intensity
sigma = 0.05 # spot size
[5]:
# Generate a 10th degree map with linear limb darkening
np.random.seed(0)
map = starry.Map(10, 1)
map[1] = u1
omega_eq = 360.0 / P
time = np.linspace(0, 30, 1000)
time_ani = time[::10]
true_flux = np.zeros_like(time)
res = 300
true_image_rect = np.zeros((len(time_ani), res, res))
true_image_ortho = np.zeros((len(time), res, res))
# Generate light curves for three spots
true_lats = [-30, 30, -20]
true_lons = [-90, 60, 135]
for lat, lon in zip(true_lats, true_lons):
# The angular velocity at the current latitude, computed
# from the equation for linear differential rotation
omega = omega_eq * (1 - alpha * np.sin(lat * np.pi / 180.0) ** 2)
# Reset the map coefficients & add a new spot
map.reset()
map.inc = inc
map[1] = u1
map.add_spot(intensity=intensity, sigma=sigma, lat=lat, lon=lon)
# Add to the flux
true_flux += map.flux(theta=omega * time)
# Add to our sky-prjected image
true_image_ortho += map.render(theta=omega * time)
# Hack: to get our lat-lon image, we need to manually
# shift the image of each spot according to how far it
# has lagged due to differential rotation. Sorry --
# there's no easy way to do this in starry currently!
tmp = map.render(projection="rect")
shift = np.array((omega - omega_eq) * time_ani * res / 360, dtype=int)
for n in range(len(time_ani)):
true_image_rect[n] += np.roll(tmp, shift[n], axis=1)
# Normalize and add a little bit of noise
flux_err = 1e-5
flux = true_flux / np.nanmedian(true_flux)
flux += flux_err * np.random.randn(len(time))
We can visualize the map by passing in the image arrays. Let’s look at it in sky projection:
[6]:
map.show(image=true_image_ortho, projection="ortho")
and in lat-lon coordinates that co-rotate with the equator (note that limb darkening is disabled in this projection by default):
[7]:
map.show(image=true_image_rect, projection="rect")
Here’s the light curve we’re going to do inference on. You can tell there’s some differential rotation because of the change in the morphology over time:
[8]:
plt.plot(time, true_flux / np.nanmedian(true_flux), "C0-", lw=1, alpha=0.5)
plt.plot(time, flux, "C0.", ms=3)
plt.gca().get_yaxis().get_major_formatter().set_useOffset(False)
plt.xlabel("time [days]")
plt.ylabel("flux [normalized]");
There are several ways to model this with starry
, so let’s go over each one.
1. Using a Taylor expansion¶
Recall that in starry
, the flux is a linear function of the spherical harmonic coefficient vector:
where \(\mathbf{f}\) is the flux vector, \(\mathbf{A} = \mathbf{A}(\Theta)\) is the design matrix (a function of a bunch of parameters \(\Theta\)) that transforms the map to a light curve, and
is the vector of spherical harmonic coefficients \(\mathbf{y}\) weighted by the map amplitude \(a\) (a value proportional to the luminosity of the map). If the map is time variable, we can express this by allowing \(\mathbf{x}\) to be a function of time: \(\mathbf{x} = \mathbf{x}(t) = a(t) \mathbf{y}(t)\). To make this tractable, we can Taylor expand this vector about \(t=0\):
The corresponding flux vector (i.e., the light curve) is then
which we can write in matrix form as
where
is an augmented design matrix and
is the vector of spherical harmonic coefficients and their derivatives.
We can therefore linearly solve for the coefficients and their derivatives if we just augment the design matrix in this fashion (and provide suitable priors). Let’s do that below.
Let’s instantiate a map. We’ll solve for the map up to \(l = 5\) only and go up to 4th derivatives in the Taylor expansion. Note that we are solving for \(4 \times (5 + 1)^2 = 144\) coefficients in total, so we’ll need some good regularization to prevent overfitting.
[9]:
map = starry.Map(5, 1)
map.inc = inc
map[1] = u1
order = 4
Here’s how to build the augmented design matrix:
[10]:
# Compute the usual design matrix
theta = 360.0 / P * time
A0 = map.design_matrix(theta=theta)
# Normalize and center the time array
# (to help with numerical stability)
t = 2.0 * (time / time[-1] - 0.5)
# Horizontally stack the quantity 1/n! A0 t^n
coeff = 1.0 / factorial(np.arange(order + 1))
T = np.vander(t, order + 1, increasing=True) * coeff
A = np.hstack([(A0 * T[:, n].reshape(-1, 1)) for n in range(order + 1)])
Here’s what that looks like (the derivative orders are indicated):
[11]:
plt.imshow(A, aspect="auto")
[plt.axvline(n * map.Ny - 1, color="k") for n in range(1, order + 1)]
[
plt.text(n * map.Ny - 1 + map.Ny / 2, len(t) / 2, n, color="k")
for n in range(order + 1)
]
plt.gca().axis("off")
plt.colorbar();
Now we’ll tackle the linear problem.
Note
Since this is still an experimental feature, the user interface is a little clunky. Solving the linear problem for temporal maps will become easier in the next release of the code!
We’re going to use the solve
method in the linalg module to solve a custom linear system. We’ll set the prior mean of the coefficients to zero, except for the first one, which we set to unity (since this is the prior on the map amplitude). We’ll give all the coefficients a prior variance of \(10^{-2}\), except for the first one, whose variance we’ll set to unity.
[12]:
mu = np.zeros(A.shape[1])
mu[0] = 1.0
L = np.ones(map.Ny * (order + 1)) * 1e-2
L[0] = 1.0
x, cho_cov = starry.linalg.solve(A, flux, C=flux_err ** 2, mu=mu, L=L)
The solve
method returns the amplitude-weighted coefficients x
and the Cholesky factorization of the posterior covariance. Let’s plot the best fit model against the data:
[13]:
model = A.dot(x)
plt.plot(time, flux, ".", ms=3, label="data")
plt.plot(time, model, label="model")
plt.ylabel("flux [normalized]")
plt.xlabel("time [days]")
plt.legend();
That looks really good! The residuals are fairly white:
[14]:
plt.plot(time, flux - model, ".", ms=3, label="data")
plt.axhline(flux_err, color="C0", alpha=0.2)
plt.axhline(-flux_err, color="C0", alpha=0.2)
plt.ylabel("residuals")
plt.xlabel("time [days]");
Let’s now visualize the solution. Recall that the coefficients of the map at time \(t\) are given by
[15]:
# Allocate the image
image = np.empty((len(time_ani), res, res))
# Compute the weights of each coefficient in the Taylor expansion
t_ani = 2.0 * (time_ani / time_ani[-1] - 0.5)
T_ani = np.vander(t_ani, order + 1, increasing=True) * coeff
# At each point in time, compute the map coefficients
# and render the image
for n in range(len(time_ani)):
xn = x.reshape(order + 1, -1).T.dot(T_ani[n])
map.amp = xn[0]
map[1:, :] = xn[1:] / map.amp
image[n] = map.render(res=res, projection="rect")
[16]:
map.show(image=image, projection="rect")
map.show(image=true_image_rect, projection="rect")
The posterior mean map is shown at the top and the original map is shown at the bottom. We’re able to recover the three spots and the general westward motion due to differential rotation, even though we never explicitly assumed anything about the number / shape / size of the spots or the strength of the differential rotation. There are, however, lots of artifacts in the solution, and one of the spots seems to disappear toward the end. They are also elongated latitudinally.
Note, however, that this is a fundamental limitation of the mapping problem, since the null space is huge! Unless we have good prior information, in many cases our maps will look nothing like the true image of the star.
2. Modeling differential rotation¶
Now let’s explicitly assume the variability we see is due to differential rotation. This is an experimental feature in starry
, which you can read more about here. The idea is to Taylor expand the differential rotation operator and truncate the differentially-rotated map to the current map resolution. This is slow and becomes unstable as time goes on (since polynomials diverge toward infinity!) Below, we’re using a 2nd order expansion, which will help
in modeling all 30 days of data at once. But it comes at the cost of extra computational overhead, so we’re going to again limit the map to a degree 5 spherical harmonic expansion.
Note
We’re still working on the differential rotation operator, so it will likely become a lot more efficient in the near future!
[17]:
map = starry.Map(5, 1, drorder=2)
map.inc = inc
map.alpha = alpha
map[1] = u1
# Set the prior as before.
# We place a stronger prior on the coefficients
# to prevent the solution from blowing up (since
# the differential rotation operator isn't very
# numerically stable).
mu = np.zeros(map.Ny)
mu[0] = 1.0
L = np.ones(map.Ny) * 1e-4
L[0] = 1.0
map.set_prior(mu=mu, L=L)
map.set_data(flux, C=flux_err ** 2)
Center the array of rotational phases for numerical stability:
[18]:
tmid = 0.5 * (time[-1] - time[0])
theta = 360.0 / P * (time - tmid)
Solve the linear problem (note that this automatically sets the map’s coefficients to the maximum a posteriori solution):
[19]:
%%time
soln = map.solve(theta=theta)
CPU times: user 1.02 s, sys: 4.15 ms, total: 1.02 s
Wall time: 1.02 s
Compute and plot the model and the residuals:
[20]:
%%time
model = map.flux(theta=theta)
CPU times: user 1.1 s, sys: 64 ms, total: 1.16 s
Wall time: 1.06 s
[21]:
plt.plot(time, flux, ".", ms=3, label="data")
plt.plot(time, model, label="model")
plt.ylabel("flux [normalized]")
plt.xlabel("time [days]")
plt.legend();
[22]:
plt.plot(time, flux - model, ".", ms=3, label="data")
plt.axhline(flux_err, color="C0", alpha=0.2)
plt.axhline(-flux_err, color="C0", alpha=0.2)
plt.ylabel("residuals")
plt.xlabel("time [days]");
The fit is decent, but note how the scatter is much larger than the standard deviation of the data (blue lines).We’re also struggling to model the light curve at the edges of the timeseries. The oscillatory pattern in the residuals is due to the fact that our model assumes perfect differential rotation; i.e., that all features get sheared over time depending on their latitude. Our synthetic dataset consists of circular spots that move relative to each other, but don’t themselves undergo any shearing.
Here’s what the actual surface looks like:
[23]:
map.show(theta=theta, projection="rect")
map.show(image=true_image_rect, projection="rect")
One could argue that there are three features in the solution that kind of track the true spots, but they’re shifted in latitude and elongated in longitude. They are also very prior-dependent (try experimenting with the value of \(\Lambda\)).
3. Spots rotating at different rates¶
Finally, we could place an even stronger prior on the problem and assume the stellar surface consists of a few discrete spots undergoing differential rotation.
Since the starry
model is linear, we can instantiate several maps rotating at different rates, compute their light curves, and add them all together. We scale the result by the free variable scale
to get the normalization correct.
We’re going to define a pymc3
model for the problem, but we’re not going to do any sampling – rather, we’re going to use the optimize
function from exoplanet
to find the best spot properties (and that requires a pymc3
model).
As we will see, finding the correct spot parameters is extremely difficult even when our model is exactly the correct description of the problem. That’s because the likelihood space is extremely degenerate and extremely multi-modal. Optimization yields completely different results depending on how exactly we initialize the solver and on how stringent our priors our. For simplicity, below we assume we know everything except for the latitude and longitude of each of the spots and the overall light curve normalization. We therefore fix the spot intensity, size, and differential rotation parameter at their true values. As we will see, even in this ideal case, we only get the correct solution if we initialize the solver very close to the true spot locations!
Warning
This next bit requires lazy
evaluation mode. Switching between evaluation modes within a Python
session is not currently supported. We do it below, but this is not advised in general, as it may
lead to unexpected behavior.
[24]:
# Switch evaluation modes.
# WARNING: Don't try this at home! Start a new Python session instead.
starry.config._lazy = True
Let’s define a function that instantiates a pymc3
model and runs an optimizer to find the spot locations. The function returns the best model for the light curve and for the image of the surface.
[25]:
import pymc3 as pm
import exoplanet as xo
def solve(lat_guess, lon_guess):
nspots = len(lat_guess)
with pm.Model() as model:
# Keep track of these things
map = [None for n in range(nspots)]
frac = [None for n in range(nspots)]
flux_model = [None for n in range(nspots)]
omega = [None for n in range(nspots)]
# Flux normalization
scale = pm.Uniform("scale", lower=0, upper=1.0, testval=1.0 / nspots)
# Add each spot
for n in range(nspots):
# Spot parameters
lat = pm.Uniform(
"lat{}".format(n), lower=-90, upper=90, testval=lat_guess[n]
)
lon = pm.Uniform(
"lon{}".format(n), lower=-180, upper=180, testval=lon_guess[n]
)
# Instantiate the map and add the spot
map[n] = starry.Map(10, 1)
map[n].inc = inc
map[n][1] = u1
map[n].add_spot(
intensity=intensity, sigma=sigma, lat=lat, lon=lon,
)
omega[n] = omega_eq * (1 - alpha * np.sin(lat * np.pi / 180.0) ** 2)
flux_model[n] = map[n].flux(theta=omega[n] * time)
# Compute the model
flux_model = scale * pm.math.sum(flux_model, axis=0)
pm.Deterministic("flux_model", flux_model)
# Save our initial guess
flux_model_guess = xo.eval_in_model(flux_model)
# The likelihood function
pm.Normal("obs", mu=flux_model, sd=flux_err, observed=flux)
# Optimize!
map_soln = xo.optimize()
# Render the map
image = np.zeros((len(time_ani), res, res))
for n in range(nspots):
tmp = xo.eval_in_model(
map[n].render(projection="rect", res=res), point=map_soln,
)
shift = np.array(
(xo.eval_in_model(omega[n], point=map_soln) - omega_eq)
* time_ani
* res
/ 360,
dtype=int,
)
for n in range(len(time_ani)):
image[n] += np.roll(tmp, shift[n], axis=1)
# Return the model for the flux and the map
return map_soln["flux_model"], image
In our first experiment, we initialize the spot locations at random values centered on the true locations and with a standard deviation of 5 degrees. These are therefore very good guesses. Let’s see how we do:
[26]:
np.random.seed(0)
lat_guess = true_lats + 5 * np.random.randn(3)
lon_guess = true_lons + 5 * np.random.randn(3)
model1, image1 = solve(lat_guess, lon_guess)
optimizing logp for variables: [lon2, lat2, lon1, lat1, lon0, lat0, scale]
105it [00:06, 15.97it/s, logp=1.009628e+04]
message: Desired error not necessarily achieved due to precision loss.
logp: -864216304.0448056 -> 10096.279660690363
There was a huge improvement in the log likelihood! Here’s the final model and residuals:
[27]:
plt.plot(time, flux, ".", ms=3, label="data")
plt.plot(time, model1, label="good initial guesss")
plt.ylabel("flux [normalized]")
plt.xlabel("time [days]")
plt.legend();
[28]:
plt.plot(time, flux - model1, ".", ms=3, label="data")
plt.axhline(flux_err, color="C0", alpha=0.2)
plt.axhline(-flux_err, color="C0", alpha=0.2)
plt.ylabel("residuals")
plt.xlabel("time [days]");
We have undoubtedly found the correct solution:
[29]:
map.show(image=image1, projection="rect")
map.show(image=true_image_rect, projection="rect")
Now, to drive home the point of how difficult it is to model light curves with discrete spots, let’s instead initialize the solver with a slightly higher standard deviation in our guesses: 15 degrees:
[30]:
np.random.seed(0)
lat_guess = true_lats + 15 * np.random.randn(3)
lon_guess = true_lons + 15 * np.random.randn(3)
model2, image2 = solve(lat_guess, lon_guess)
optimizing logp for variables: [lon2, lat2, lon1, lat1, lon0, lat0, scale]
135it [00:06, 21.54it/s, logp=-1.057833e+07]
message: Desired error not necessarily achieved due to precision loss.
logp: -1477879284.743772 -> -10578334.480908247
Note how our log likelihood is much, much smaller than before. Here’s the model:
[31]:
plt.plot(time, flux, ".", ms=3, label="data")
plt.plot(time, model2, label="bad initial guesss")
plt.ylabel("flux [normalized]")
plt.xlabel("time [days]")
plt.legend();
[32]:
plt.plot(time, flux - model2, ".", ms=3, label="data")
plt.axhline(flux_err, color="C0", alpha=0.2)
plt.axhline(-flux_err, color="C0", alpha=0.2)
plt.ylabel("residuals")
plt.xlabel("time [days]");
The residuals are orders of magnitude larger than the flux uncertainty. Check out the “best” map:
[33]:
map.show(image=image2, projection="rect")
map.show(image=true_image_rect, projection="rect")
We clearly converged to a (very bad) local minimum that doesn’t even come close to describing the true surface of the star.
The bottom line here is that unless we have a very good initial guess (and/or a very good prior), it is really hard to do optimization in this space. However, if you’re patient, you could try initializing the solver at many different locations. You could also try optimizing for only a few variables at a time (for instance, solve for the position of the first spot with the other two fixed, then the position of the second spot with the other two fixed, and so forth), which sometimes helps with convergence. But that’s all beyond the scope of this simple tutorial.
Summary¶
We discussed three different methods to model time variability. Arguably none of them did particularly well. The discrete spot model got the correct solution when we fixed most of the parameters at their true values and started with a really good initial guess, but that’s hardly ever going to help us with real data. The differential rotation model was pretty meh and isn’t scalable to high degrees or long light curves because of how unstable the expansion of the differential rotation operator is. I’m a fan of the Taylor model, but it is quite ill-conditioned and therefore needs very strong priors to avoid overfitting. For real data, you should experiment with all three models, as some may perform better depending on the problem.
Kepp in mind that in all cases, the only way to get a good solution is to have a good prior (or a good initial guess). That’s because of the ever-present issue of the null space. The mapping problem is difficult enough when the maps are static, and becomes nearly intractable when there’s time variability.
However, there are many ways to maximize the information one can obtain about a stellar surface when there’s time variability, and they all rely on techniques to break degeneracies. Please refer to the null space tutorial for more information.


Database servers can work together to allow a second server to take over quickly if the primary server fails (high availability), or to allow several computers to serve the same data (load balancing). Ideally, database servers could work together seamlessly. Web servers serving static web pages can be combined quite easily by merely load-balancing web requests to multiple machines. In fact, read-only database servers can be combined relatively easily too. Unfortunately, most database servers have a read/write mix of requests, and read/write servers are much harder to combine. This is because though read-only data needs to be placed on each server only once, a write to any server has to be propagated to all servers so that future read requests to those servers return consistent results.
This synchronization problem is the fundamental difficulty for servers working together. Because there is no single solution that eliminates the impact of the sync problem for all use cases, there are multiple solutions. Each solution addresses this problem in a different way, and minimizes its impact for a specific workload.
Some solutions deal with synchronization by allowing only one server to modify the data. Servers that can modify data are called read/write, master or primary servers. Servers that track changes in the master are called standby or slave servers. A standby server that cannot be connected to until it is promoted to a master server is called a warm standby server, and one that can accept connections and serves read-only queries is called a hot standby server.
Some solutions are synchronous, meaning that a data-modifying transaction is not considered committed until all servers have committed the transaction. This guarantees that a failover will not lose any data and that all load-balanced servers will return consistent results no matter which server is queried. In contrast, asynchronous solutions allow some delay between the time of a commit and its propagation to the other servers, opening the possibility that some transactions might be lost in the switch to a backup server, and that load balanced servers might return slightly stale results. Asynchronous communication is used when synchronous would be too slow.
Solutions can also be categorized by their granularity. Some solutions can deal only with an entire database server, while others allow control at the per-table or per-database level.
Performance must be considered in any choice. There is usually a trade-off between functionality and performance. For example, a fully synchronous solution over a slow network might cut performance by more than half, while an asynchronous one might have a minimal performance impact.
The remainder of this section outlines various failover, replication, and load balancing solutions. A glossary is also available.


Important Notice:
This "backup" is NOT a full and proper backup of your EXODUS system.
It is an internal consistency check and copy of the EXODUS database.
A full and proper backup of your data will be an automatic daily complete copy of
the
EXODUS software and data with periodic off-site storage. All to be setup, monitored,
and certified by your own technical support staff.


UTC
West African franc CFA (Communauté financière africane). Franc=100 centimes.
All the major Credit Cards are widely accepted. Travellers cheques can be readily exchanged at banks and are accepted in many hotels, restaurants and shops.
International Dialing Code for Ivory Coast is +225.
Mobile GSM services are available around the main towns and cities.
There are Internet cafes in Abidjan.
Emergencies
Police - Dial 110, 111, 170
Fire Department - Dial 180
IMRAY AND ADLARD COLES PILOT BOOKS are available at a discounted price for Noonsite.com users via World Cruising Club
Noonsite welcomes information and updates especially regarding clearance, customs and immigration procedures from cruisers visiting this country.
Please E-mail noonsite with any new information, updates or corrections. Even just a short email confirming that the current data is accurate would be most helpful.


On this day I was in a mostly neutral attitude, pretty bored as nothing had happened, but I had a shipment of herbs coming in. Among them were Nelumbo nucifera stamens, Klip strain wild dagga, syrian rue, kava, and others, but the two I tried this day were kanna and powdered kratom.
I started by creating a line of the powdered light green kanna, pulled out a couple small stems and insufflated it with a $20 bill. It surprisingly was smooth to insufflate at first, and while I did sneeze a bit later, and have a sour drip, it was tolerable. After snorting the kanna, I went on the computer and listened to Kashmir by Led Zeppelin, but as the minutes passed I felt nothing. I went on a walk under the moonlight, and half an hour later I felt what may have been simple placebo. Kanna did not do anything, and by 2 hours later I was ready for something else.
I made some tea with a Green Tea/Earl Grey combination, and poured a spoonful or two of kratom in. I stirred it vigorously, and took a sip. It tasted disgusting, like a sour metal tea, so I poured a shitload of honey into the tea/kratom combination, and finally it was palatable, maybe even good if not for the floating particles of kratom I ingested. I consumed this over a few minute period, and waited.
At first I felt floaty, and as I moved my neck back my head felt weirdly unhinged. As time went on, I grew relaxed and a bit more open, maybe like I would feel after a couple hits of cannabis, and just chilled out to some Grateful Dead. This relaxation continued for a few hours, it was nothing too intense. Kratom may be useful for meditation, as it was relaxing and helped quiet the mind, but it wasn't really comparable to any real drugs. Maybe at higher doses kratom would be more recreational, but I took at least a fifth of the ounce bag and only felt this relaxation. Next time I will try a much higher dose, at least doubled, but it is possible that kratom has some potential.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Adelaide weather: Christmas 2019, the Bureau of Meteorology gives us a sneak peek at what’s in store
Searching for the Adelaide Christmas weather forecast? Here’s an early look at what’s in store as the big day approaches.
The latest Bureau of Meteorology Climate Outlook suggests a warmer and drier than average day is on the cards.
Supervising meteorologist Matt Bass says the average maximum temperature on Christmas Day in Adelaide at West Terrace is 27.9C and the forecast is likely to be warmer than average.
“So typically quite nice conditions, but this time of the year in Adelaide anyway, as I’m sure anyone knows, locally we do tend to see quite large swings in temperature in the early summer period,” he said.
“If we get the northerlies, we can easily spike up to 40 degrees and if we get a decent cool change it will be in the low 20s or so, so in some ways the average of 28 hides the fact that we do have quite a lot of variability.”
Three of the last four Christmas Days have been hot, above 35C. Last year the mercury reached 36.2C at West Terrace (37.9C at Kent Town, then 2017 was 29.4C, 2016 was 41.3C, 2015 was 37.2C and 2014 was 23.5C).
“The hottest ever Christmas Day we’ve had at the West Terrace site was 42.1C all the way back in 1888, so a pretty long time ago,” Mr Bass said.
But there’s a fairly large gap in the record for West Terrace, which is now the official site for Adelaide. Observations cover the years 1871–1979 and 2017 to the present day.
Kent Town was fills in the gap from 1977 to 2017 but the Bureau says obstruction by nearby buildings is potentially jeopardising the reliability of measurements at that site.
And don’t worry about getting wet because 80 per cent of the time it’s totally dry on Christmas Day, Mr Bass says, and then the chance of getting at least five or more millimetres is around 8 per cent.
The last time we had any measurable rain on Christmas Day was back in 2001.
The Climate Outlook released late on Monday, December 9, shows Adelaide has a 60 to 70 per cent chance of exceeding the average Christmas temperature.
Interestingly it’s a different story for minimum temperatures, which are slightly more likely to be below average (there’s a 35 to 45 per cent chance of above average minimum temperatures).
The rainfall signal for the week shows a 60 to 70 per cent chance of being below average, so there’s a drier outlook for the week of Christmas than usual in December.
But check back in with us and the Bureau one week before the big day, for the 7-day forecast.
Past five years of Christmas weather in Adelaide, recorded at Kent Town:
2018 37.9C
2017 29.4C
2016 41.3C
2015 37.2C
2014 23.5C


--- layout: post permalink: ukproxyserver.html Tags: Array NameOfCoupon: UK Proxy Server Cash Back Summary: See our UK Proxy Server Coupon Code, UK Proxy Server Rebate, UK Proxy Server Promo Code, UK Proxy Server Discount, UK Proxy Server Coupon Cash Back Rebate here. MetaKeywords: UK Proxy Server Coupon Code, UK Proxy Server Rebate, UK Proxy Server Promo Code, UK Proxy Server Cash Back Rebate, UK Proxy Server Discount, UK Proxy Server Coupon Image: images/28075.gif LinkURL: http://www.shareasale.com/r.cfm?b=240449&u=412002&m=28075 affiliate_url_link: http://www.icouponblog.com/jane.php?id=3491 thesis_readmore: See the UK Proxy Server Coupon thesis_thumb: http://www.icouponblog.com/tn.php?merchantURL=ukproxyserver.co.uk Title: Save 10% - UK Proxy Server Coupon Code for ukproxyserver.co.uk. UK Proxy Server Rebate & Discount thesis_description: Our UK Proxy Server Discount Coupon Code for ukproxyserver.co.uk. We have the best UK Proxy Server Rebate anywhere. thesis_keywords: UK Proxy Server, UK Proxy Server Coupon Code, UK Proxy Server Discount, UK Proxy Server Rebate product_name: UK Proxy Server hop_url: http://www.icouponblog.com/hop.php?id=3491 ---
Get more secure when you go on the net. Get your own UK ip address with UK proxy or vpn server. Use www.ukproxyserver.co.uk. You will get this at an amazingly low price starting in single digits! Speed up your localized file requests, reduce international bandwidth restrictions, and ease the load on web and file transfer protocol (FTP) servers by subscribing to www.ukproxyserver.co.uk. Use our discount coupons to get a great service at a great price.
If you live in the U.K, France, Canada, Germany, Switzerland, the U.S and etc, and travel out of the country, you can still access your internet the same way as you would in your own home. Subscribe to www.ukproxyserver.co.uk and get all the benefits of having a UK proxy server including, faster connection to your favorite UK websites and much more. Check it out, its inexpensive and a great service. You will also have quick access to their help desk if you need any assistance. Subscribe to www.ukproxyserver.co.uk today and get a UK proxy or VPN server. Their server has been configured specifically to allow access to common websites and internet resources, such as: MSN, Skype, EBay, Face book, MySpace, Yahoo, Friendster, Bebo, BBC iPlayer, ITV Catch-up, 4OD and many more. Their service is also compatible with several web browsers, including Internet Explorer and Firefox. It is very affordable and wherever you use it in the world, you will get the best possible service as though you have not left home.