Monitoring Tools
PHD2 provides numerous monitoring and
display tools to help you see how your guider is performing.
All
of these tools are accessed under the 'View' pull-down menu and are described below.
Overlays
The
simplest display tools are grid overlays superimposed over the
main guider display window. These are quite straightforward
and
include the following choices:
- Bullseye target
- Fine grid
- Coarse grid
- RA/Dec - this shows how the telescope axes are aligned
relative to the axes of the camera sensor. This is a visual
confirmation that there is no need or benefit to worrying about
trying to align the camera axes with RA and Dec.
- Spectrograph
slit/slit position - for spectroscopy users, this will overlay a
spectrograph slit graphic on the main display window. The size,
position, and angle of the graphic can be adjusted to match the
optical configuration.
- None
You can just click on the various overlay options under the 'View' menu
and choose one that suits you.
Graphical Display
The
graphical display window is one of the more powerful tools for judging
guiding performance, and you will probably learn to rely on it.
A typical example is shown below:
The
major portion of the window shows the detailed displacements of the
guide star for each guide exposure, plotted left-to-right.
Normally, one line shows displacements in right ascension while
the second line shows declination displacements. However, you can
use the 'Settings' button to the left of the graph to switch to camera
(X/Y) axes if you prefer (not recommended). You can also use the 'Settings' button
to switch between display units of arc-seconds vs. camera pixels or to
change the colors of the two graph lines. The range of the
vertical axis is controlled by the second button from the top, labelled
y:+/-4" in this example. The range of the horizontal axis - the
number of guide exposures being plotted - is controlled by the
topmost button, labelled x:50 in this example. This scale also
controls the sample size used for calculating the
statistics you see in the lower left part of the graph window.
These values show the root-mean-square (RMS or standard
deviation) of the motions in each axis along with the total for both
axes. These are your best estimators of guiding
performance because they can be directly compared to star sizes and
seeing conditions. The 'RA
Osc' value shows the odds that
the current RA move is in the opposite direction as the last RA move.
This is a carry-over statistic from the original PHD software and
its usefulness is limited. If it consistently runs above
0.5, you may be chasing the seeing because of a Min-Move value that is
too low. There are two
other checkboxes to the left that can help you evaluate guider
performance. Clicking on the 'Corrections' box results in an
overlay showing when guide commands are actually sent to the mount,
along with their direction and magnitude. In this example, these
are shown as the vertical red and green lines appearing at irregular
intervals along the horizontal axis. This shows you how "busy"
the guiding is - under optimal conditions, you should expect to see
extended intervals when no guide commands are sent at all in Declination. The
other checkbox, labelled 'Trendlines',
will superimpose trend lines in
both axes to show if there is a consistent overall drift in the star
position. This is primarily useful for drift aligning where the
declination trendline is used extensively. But the RA trendline
can show if your mount is tracking systematically slow or fast (or is
seeing the effects of flexure) and can
help if you are trying to set up custom tracking rates. The trend
line for Dec is also useful if you're trying to choose the correct
direction for uni-directional Dec guiding. If
dithering commands are issued, usually by an external imaging
application, a 'dithering' label will be superimposed on the graph in
the appropriate time interval. This tells you the star
displacements being graphed are being influenced by the dithering
operation. The RMS statistics do not include the large excursions
associated with dithering and settling.
The
guiding graph will also show the directions (GuideNorth,
GuideEast) associated with the guide commands, as shown in the example
above. This can be helpful if you are looking at overall drift
and want to determine how to set uni-directional guiding for
declination. These directions show how the guide star is drifting
away from the lock position. For example, if the Dec position of
the guide star is moving upward in the graph, the guide star appears to be
drifting "north" on the camera sensor. This means that south guide
pulses will be needed to move it back to the lock position.
Similarly, a downward drift in RA location means the the guide
star is moving "east" on the camera sensor and west guide pulses will be
applied. For the purpose of setting up uni-directional Dec
guiding, these rules apply:
Dec drifting upward => select Dec guide mode = South
Dec drifting downward => select Dec guide mode = North
For
various mount and hardware reasons, these directions may not correspond
to actual directions in the sky, particularly for Dec, but that doesn't matter.
The recommended way to look at guiding
performance is to use units of arc-seconds rather than pixels.
Doing this allows an equipment-independent way of evaluating
performance because it transcends questions of focal length and image
scale. To do this, you need to provide PHD2 with sufficient
information to determine your guider image scale: namely, the focal
length of the guide scope, the size of the guide camera pixels, and whatever binning level you're using.
Using the new-profile-wizard is the best way to insure these settings are correct.
At
the bottom
of the graph window are active controls for adjusting guiding
parameters "on the fly". The guiding algorithm selections you've
made will determine which controls are shown. These controls have
the same
effect as those in the 'Brain' dialog, and they eliminate the
need to stop guiding and navigate to another window to adjust
guiding parameters. Although these controls are prominently
displayed, it is generally not productive to change them substantially
during guiding. Guiding
improvements normally require long guiding intervals and careful
analysis using the PHD2 LogViewer tool. Poor guiding results
usually arise
from user error, from mechanical problems in the mount, or from
movement of the gear on the mount. Blindly changing guiding
parameters doesn't help with any of these things and usually makes
matters worse.
Stats
If
you want to monitor guiding performance without necessarily having the
graph window open, you can click on the "Stats" menu item.
That will display the salient statistics with controls for
clearing the data or changing the number of guide exposures used to
compute the statistics. The tracking statistics are the same as
those in the Graph tool, and like those, don't include the effects of
dithering and settling. This window is also useful for
confirming camera binning, monitoring the guide camera
temperature, and getting a quick calculation of your guide camera's
field of view.
Star Profile and Target Displays
The
star profile display shows the cross-section of the guide star along
with measurements of its full-width-half-maximum (FWHM)
and half-flux-diameter (HFD).
HFD is generally a more stable measure of the star size since
it doesn't require curve fitting or any assumption about the overall
shape of the star image. If you
see substantial fluctuations in this parameter or wildly varying star
profiles, it may be an indication
that the star is too faint, the exposure time is too short, the camera is out-of-focus, or the seeing is poor.
This
tool can help with focusing the
guide camera, a
procedure that can be tedious if you're using an off-axis-guider
or a small finder-scope. For purposes of focusing, the HFD
number
is shown in a large font so you can see it from a distance while
focusing your guide scope/camera. Just un-dock the Star Profile
window and expand it until you can see the HFD number easily. If
you are starting well out-of-focus, you'll probably see only a few
fuzzy stars in the frame, so just choose the smallest one that is
clearly visible. Use exposure times of at least 2 seconds if
possible so you don't chase the seeing. At the same time, don't
let the star become saturated, showing a distinctive flat top.
Now adjust the focus so the HFD gets consistently
smaller - but stop as soon as HFD reverses direction or seems to
plateau. At that point, the star may be saturated, so move to a
dimmer star in the field. Since you have already improved the
focus, you can hopefully see a dimmer star. Continue in this way
until you've reached a focus point that shows a minimum level of HFD
for the faintest star you can use. At each point in the focusing
process, you'll probably want to watch the HFD values for a few frames
so you can mentally average out the effects of seeing. Bad
focus is a common issue for beginners, leading to problems in
calibration or poor guiding results. You can also use a Bahtinov
focus mask or another app like SharpCap for focusing. In general,
you can't reach critical focus by simply looking at the stars in the
image display - you need some sort of measurement help to get a good
result. During guiding, you can use the Star
Profile tool to be sure the star doesn't have a flat top (saturation)
and shows a tapered shape like the example shown above. If the
star profile window is large enough, it will also show the decimal X/Y
coordinates of the star centroid.
The
target display is another useful way to visualize overall guider
performance. The red 'X' shows the star displacement for the most
recent guide exposure, while the blue dots show the recent history.
You can zoom in or out with the controls at the upper left of the
window, as well as change the number of points shown in the history.
If you are using an ASCOM connection for either the 'mount' or
'aux-mount', PHD2 will also show the directions (SkyNorth, SkyEast)
associated with the star movement, as shown in the example above.
This can be helpful if you are looking at overall drift and want to
determine how to set uni-directional guiding for declination. The
up/down convention used in this graph has nothing to do with the camera
orientation or N-S-E-W movements in the field of view.
Adaptive Optics (AO) Graph
The
AO graph is equivalent to the 'target' display, but shows the history
of corrections relative to the axes of the adaptive optics device.
The red rectangle indicates the outer edges of the AO device,
while the interior yellow rectangle shows the "bump" region. If
the star moves outside the yellow rectangle, PHD2 will send a sequence
of move commands to the mount - the "bump" - to smoothly place the guide star back
near the center position. When this occurs, green and blue lines
will show the incremental bump and the remaining bump respectively.
The white dot on the display shows the current AO position, and
the green circle (red when a bump is in progress) shows the averaged AO position. The button in
the upper left controls how many points will be
plotted in the history.
Dockable/Moveable Graphical Windows
When
the various performance windows are initially displayed, they are
"docked" in the main window. This means they are sized in a
particular way and are aligned with two edges of the window - they are
entirely contained within the bounds of the main PHD2 window.
However, you can move them around and resize them by clicking and
dragging on the title bar of the window you want to examine. This
will often let you get a better view of the details being shown in the
graphs. They can be re-docked by dragging the title bar to the
general region in which you want them docked - bottom, right, etc.
With just a bit of practice, it's easy to place them where they
are most convenient.
There is also a menu item under the 'View" pulldown menu labeled 'Restore
window positions.' Clicking on this menu item will automatically
restore all of the dockable/moveable windows to their default, docked
positions. This can be useful , for example, if you are switching
between screens with different resolutions and one or more of the
dockable windows has been "lost." This function also restores the
main PHD2 window to its default size, with a position near the upper
lefthand corner of the screen.


Latest News
24 Απρ 2018
Helix data principles: how well known or understood are they?
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
24 Απρ 2018
Helix, Nectar and RDS partnership
Aligning research infrastructure Helix is partnering with Nectar and RDS to deliver transformation in the research sector.
About Helix
Research for Data
Find, access, and reuse data from Australian research organisations, agencies and institutions via Hellix flagship service.
Find research data
Our partners
Helix collaborates with universities and other research institutions to enhance the value of data and enable new discoveries.
Who we work with
The project
Hellix-Nectar-RDS News is a great source of news, events and data jobs - sent direct to your inbox every fortnight. Sign up now to get the next edition.
Don't miss out!
Deliverables
Hellix-Nectar-RDS News is a great source of news, events and data jobs - sent direct to your inbox every fortnight. Sign up now to get the next edition.
Don't miss out!


The Tale of Tommy Fox
by Arthur Scott Bailey
Chapter 18: “The World Turns White”
Additional Information
- Year Published: 1917
- Language: English
- Country of Origin: United States of America
- Source: Bailey, A. S. (1917). The Tale of Tommy Fox. New York: Grosset and Dunlap.
-
Readability:
- Flesch–Kincaid Level: 4.0
- Word Count: 597
- Genre: Fantasy
- Keywords: 20th century literature, american literature, children's stories, sleepy-time tales
- ✎ Cite This
Downloads
After he outwitted the strange dog, Tommy Fox became more of a braggart than ever. He thought that he knew just about all there was to know. But with the coming of winter Tommy found that he had many things to learn. It was almost like living in a different world, for the ground was white everywhere. And though Tommy Fox loved to play in the snow, he discovered one thing about it that he did not like at all. It frightened him when he saw how plainly his footprints showed after a fresh snowfall. And he wondered how he would ever be able to escape being caught, should any strange dog chase him.
As the winter days passed, Tommy learned that it was very hard for him to run fast in a light, dry snow—that through such snow a dog could run much faster than he could. But when there was a thin crust he could go skipping along like the wind, while dogs, being heavier, broke through the crust and floundered about in the softer snow beneath.
One day Tommy and his mother were out hunting. The snow was very deep everywhere, for it was mid-winter. And it had thawed and frozen so often that the snow was quite hard, except for just about an inch of fresh snow which had fallen during the night. Tommy and his mother could see rabbit tracks all around them; and they had very good luck hunting. But something happened that wasn’t exactly lucky. They had turned toward home, when a dog bayed somewhere behind them, and pretty soon Mrs. Fox saw that they were being followed.
She and Tommy started to run. And Tommy saw that there was one more bad thing about winter.
It was that strange dog that was chasing them—the one that belonged to Farmer Green’s hired man. He was a very fast runner, and in spite of the usual tricks that foxes know, Mrs. Fox and Tommy could not lose him.
Tommy began to be frightened. And old Mrs. Fox herself was somewhat worried. But she still had a few tricks up her sleeve. She didn’t intend to let that dog catch them if she could help it.
“Oh, Mother! whatever shall we do?” Tommy said. “Do you think we can get away from him?”
“Of course,” Mrs. Fox answered. “But you must do just as I tell you.
Mrs. Fox turned to the right and started back across the valley. She was going straight toward Swift River.
“Oh, dear!” Tommy cried. “Don’t you know that the river is frozen solid, Mother? The dog can follow us across it, as easy as anything.”
“Stop fussing!” Mrs. Fox said, looking over her shoulder at Tommy. “We’re not going to the river. You just mind me and you’ll see, in a few minutes, that we can fool that dog.” And she kept on running, with Tommy right at her heels.


AccuWeather: Take advantage of nicer Saturday
by WABCNEW YORK (WABC) -- Saturday is the better half of the weekend -- take advantage of the sunshine. An AccuWeather Alert goes into effect Sunday for rain.
Here is the 7-day forecast for the Tri-State area:
Saturday
Better half of weekend with a high of 47.
Sunday
Raw and rainy. High 45.
Monday
Bounce back. High 50.
Tuesday
Mild mix. High 56.
Wednesday
Tricky travel as it gets gusty. High 60.
Thursday
Cold turkey for Thanksgiving! Windy with a high of 44.
Friday
Still chilly. High of 40.
Join Sam Champion for live updates during Eyewitness News This Morning and at Noon and join meteorologist Lee Goldberg during Eyewitness News at 4:00, 5:00, 6:00 and 11:00 p.m.
Check the weather any time at abc7NY.com/weather. For weather updates wherever you go, please download the AccuWeather app.
Click here for the latest watches and warnings from the National Weather Service.


class Attachment
Constants
- DIRECT_UPLOAD_URL_FORMAT
Environment-specific direct upload url verifier screens for malicious posted upload locations. DIRECT_UPLOAD_URL_FORMAT = %r{ADIRECT_UPLOAD_URL_FORMAT = %r{\Ahttps:\/\/orasitest\.s3\.amazonaws\.com\/uploads\/.*\z}.freeze
Public Class Methods
transfer_and_cleanup(id)
click to toggle source
Final upload processing step
# File app/models/attachment.rb, line 22 def self.transfer_and_cleanup(id) attachment = Attachment.find(id) direct_upload_url_data = DIRECT_UPLOAD_URL_FORMAT.match(attachment.direct_upload_url) s3 = AWS::S3.new paperclip_file_path = "attachments/files/#{id}/original/#{direct_upload_url_data[:filename]}" s3.buckets[Rails.configuration.aws[:bucket]].objects[paperclip_file_path].copy_from(direct_upload_url_data[:path]) attachment.processed = true attachment.save s3.buckets[Rails.configuration.aws[:bucket]].objects[direct_upload_url_data[:path]].delete end
Public Instance Methods
direct_upload_url=(escaped_url)
click to toggle source
process_in_background :file
# File app/models/attachment.rb, line 17 def direct_upload_url=(escaped_url) write_attribute(:direct_upload_url, (CGI.unescape(escaped_url) rescue nil)) end
queue_processing()
click to toggle source
Queue file processing
# File app/models/attachment.rb, line 36 def queue_processing Attachment.delay.transfer_and_cleanup(id) end
Protected Instance Methods
set_upload_attributes()
click to toggle source
Set attachment attributes from the direct upload @note Retry logic handles S3 “eventual consistency” lag.
# File app/models/attachment.rb, line 44 def set_upload_attributes tries ||= 5 direct_upload_url_data = DIRECT_UPLOAD_URL_FORMAT.match(direct_upload_url) s3 = AWS::S3.new direct_upload_head = s3.buckets[Rails.configuration.aws[:bucket]].objects[direct_upload_url_data[:path]].head self.file_file_name = direct_upload_url_data[:filename] self.file_file_size = direct_upload_head.content_length self.file_content_type = direct_upload_head.content_type self.file_updated_at = direct_upload_head.last_modified # rescue AWS::S3::Errors::NoSuchKey => e # tries -= 1 # if tries > 0 # sleep(3) # retry # else # false # end end


In this blog we will have a look at the integration of Exchange 2013 with Office Web Apps What are the advantages of this change and we will have a look if there also are some disadvantages.
Starting from Exchange 2007 you needed to install the Office Converter Pack to use the preview, also known as Web Ready view, functionality in Outlook Web Access/App. This gave users the ability to read the content from for example Word files without actually opening Word. So if you had a machine which hadn’t had Word installed you were still able to view the file. This functionality is offered by using the IFilter functionality. Besides the Office Converter Pack some 3rd parties also published their own IFilter packages, for example Adobe. Keep in mind that IFilters are not only used for the preview functionality but by Exchange Search for content indexing.
Starting from Exchange 2013 you still have the ability to use IFilters for the preview functionality. But there is another method. You can offer some extra functionality to users by integrating Exchange 2013 with Office Web Apps. This software has to be installed on a separate server. The Office Web Apps server can be used to edit Excel, PowerPoint and Word files. If you want to open/edit RMS files then I must disappoint you. RMS files can’t be opened using the Office Web Apps server.
The Office Web Apps server can be deployed in many scenarios.
In the table below you will see the deployment types and there specific requirements
| Deployment | Requirements |
| Only internal |
|
|
|
| Single |
|
| Pool |
|
*recommended in production environments and required when Lync also uses the server
So what is the advantage of making this integration? Well the Office Web Apps Server will give users the ability to also edit files via a web browser. Since BYOD is a hot concept at the moment this will not require you to have the Office suite installed on your machine or tablet. Personally I think it is a big advantage for the last type. This because there is still no Office version available for the tablets.
Installing the Office Web Apps server is pretty easy:
- Install the prerequisites
- Install the Office Web App server software
- Configure the Office Wep App server
The prerequisites can be divided in two parts:
- Windows components
- Other prerequisits
The Windows components can be installed by using the servermanager module for Powershell:
Import-Module ServerManager
Add-WindowsFeature Web-Server,Web-WebServer,Web-Common-Http,Web-Static-Content,Web-App-Dev,Web-Asp-Net,Web-Net-Ext,Web-ISAPI-Ext,Web-ISAPI-Filter,Web-Includes,Web-Security,Web-Windows-Auth,Web-Filtering,Web-Stat-Compression,Web-Dyn-Compression,Web-Mgmt-Console,Ink-Handwriting,IH-Ink-Support
After the components have been installed you will need to reboot your machine to finish the installation. Once the machine is rebooted download and install the following prerequisites:
After installing the three items above you will need to reboot the server again. Once the reboot has completed it’s time to install the Office Web Apps server software. Since this is just a case of next – next finish I won’t go in to detail for this step.
Once the setup has completed it’s time to configure the Office Web Apps server. To do this we will need to use Powershell.
New-OfficeWebAppsFarm “https://owa.domain.com” –CertificateName “Office Web Apps”
In this scenario we have configured Office Web Apps to be available only via HTTPS and both the internal and external url are set to https://owa.domain.com
Now we have finished the Office Web App server side let’s have a look what has to be configured for Exchange 2013.
The configuration on the Exchange 2013 side is quite simple. Just open the Exchange Management Shell (EMS) and run the following cmdlet:
Set-OrganizationConfig -WACDiscoveryEndPoint https://owa.domain.com/hosting/discovery
In this case we will set our Office Web Apps connection point to https://owa.domain.com/hosting/discovery. When a user now uses the preview functionality Exchange will send a call to the Office Web Apps Server which will open the file.
To make this function work both on the local network as on the internet you will need to make sure it is accessible via both ways. The local network shouldn’t be a big problem so let’s continue with the internet side.
To offer the functionality on the internet we will need to publish our Office Web Apps Server to the internet. The recommend scenario is to put it behind a reverse proxy, for example TMG. Documentation on how to configure your TMG to publish Office Web Apps can be found here.
But what if you only want to allow this usage on private computers and not public computers? First of all keep in mind that the user is the one who is responsible for choosing the correct option when logging in via OWA.
But how to allow the use of the Office Web Apps Server only from private computers?
Set-OwaVirtualDirectory “EX01\owa (Default Web Site)” -WacViewingOnPrivateComputersEnabled $true -WacViewingOnPublicComputersEnabled $false
The parameter –WacViewingOnPrivateComputersEnabled will enable the use of Office Web Apps from private computers. The second parameter WacViewingOnPublicComputersEnabled will disable the feature for public computers.
| Advantages | Disadvantages |
| Gives users the ability to edit Word, Excel and PowerPoint files | Software needs to be installed on separate machine |
| No additional software is needed on the clients | Must be available from the internet if you want to offer the same services as on your local network. (for Lync 2013 this is required) |
| Can also be used by SharePoint 2013 and Lync 2013 so the server is not only used by Exchange 2013. | More than one server required in an HA environment |


Iraqi protesters killed in fresh clashes in Baghdad
Overnight confrontation near 2 key bridges in capital also reportedly injured more than 50 people.
At least two protesters have been killed and dozens of others wounded after Iraqi protesters and security forces clashed near two key bridges in the capital, Baghdad, security and medical sources said on Thursday.
The cause of death in both cases was tear gas canisters aimed directly at the head, sources told the Reuters News Agency.
One protester was killed near Sinak bridge and the other near the adjacent Ahrar bridge, police said.
Hospital sources told the agency that some of the wounded protesters had injuries sustained from live ammunition and others were wounded by rubber bullets and tears gas canisters.
Meanwhile, the AFP news agency said one of the protesters was shot dead, quoting sources.
Rights groups have slammed security forces in Iraq for firing the military-grade gas grenades directly at protesters instead of up in the air.
When shot at close range, the canisters can pierce demonstrators' skulls or chest, and advocacy groups have documented approximately two dozen such deaths.
Fifty wounded
The overnight confrontation also injured more than 50 people, including at least six who sustained gunshot wounds.
Authorities fear crowds could use the Al-Sinek bridge to reach the Iranian embassy in Baghdad and cross the adjacent Al-Ahrar bridge, further north, to protest at the Central Bank and other government buildings.
Protesters in Baghdad's Tahrir Square have criticised Tehran for propping up an Iraqi government they see as corrupt and inefficient, even accusing it of backing the use of violence against them.
More than 330 people have been killed since the protests broke out on October 1, according to an AFP toll, as authorities have stopped providing updated or precise figures.


Converts a text string representation t into a period type. The text representation should be of one of the following forms:
( timestamptz, timestamptz )
[ timestamptz, timestamptz )
( timestamptz, timestamptz ]
[ timestamptz, timestamptz ]
Where timestamptz is a valid representation of a timestamptz. The choice of brackets represents the inclusiveness of the interval. A square bracket makes that side inclusive, and a peren makes that side exclusive.
Outputs period p in the form:
[ ts1, ts2 )
Where ts1 is the text representation of the timestamptz value first(p) and ts2 is the text representation of the timestamptz value next(p).
Returns the interval value next(p) - first(p).
Returns the lowest timestamptz value that is a member of the period p.
Returns the highest timestamptz value that is a member of the period p.
Returns the timestamptz value just prior to first(p).
Returns the next timestamptz value just after last(p).
Returns true if the timestamptz value ts is included in the period p, false otherwise.
Returns true if all of the timestamptz values that are a member of the period p2 are also a member of the period p1, false otherwise.
Returns true if the timestamptz value ts is included in the period p, false otherwise.
Returns true if all of the timestamptz values that are a member of the period p1 are also a member of the period p2, false otherwise.
Returns true if next(p1) == first(p2) OR next(p2) == first(p1), false otherwise. In other words, the periods are "touching", but not overlapping.
Returns true if there is at least one timestamptz value that is a member of both periods p1 and p2.
Returns true if all timestamptz values in period p1 are less than or equal to next(p2), false otherwise.
Returns true if all timestamptz values in period p1 are greater than or equal to first(p2), false otherwise.
Returns true if there are no timestamptz values contained in the period p, false otherwise.
Returns true if period p1 is exactly the same as the period p2, false otherwise.
Returns false if period p1 is exactly the same as the period p2, true otherwise.
Returns true if all timestamptz values in the period p1 are less than all timestamptz values in the period p2, false otherwise.
Returns true if all timestamptz values in the period p1 are greater than all timestamptz values in the period p2, false otherwise.
Returns a period consisting of the single timestamptz value ts.
Returns a period from ts1 (inclusive) to ts2 (exclusive).
Returns a period containing no timestamptz values.
Returns a period consisting of all timestamptz values that are a member of both p1 and p2.
Returns a period consisting of all timestamptz values that are a member of either p1 or p2. If p1 and p2 do not overlap, and are not adjacent, an exception is raised.
Return a period consisting of all timestamptz values that are a member of p1 but not a member of p2. If p2 is contained completely inside p1 -- that is, first(p1) < first(p2) AND last(p2) < last(p1) -- an exception is raised.
temporal=> CREATE TABLE test(test_period period); CREATE TABLE temporal=> CREATE INDEX test_period_idx ON test USING GiST (test_period); CREATE INDEX temporal=> INSERT INTO test ( temporal(> SELECT period( temporal(> clock_timestamp() + (generate_series * '1 second'::interval), temporal(> clock_timestamp() + (generate_series * '20 second'::interval) temporal(> ) temporal(> FROM generate_series(1,1000001) temporal(> ); INSERT 0 1000001 temporal=> VACUUM ANALYZE TEST; VACUUM temporal=> EXPLAIN ANALYZE SELECT count(*) FROM test WHERE test_period @> (now() + (19000000 * '1 second'::interval)); QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------- Aggregate (cost=2585.05..2585.06 rows=1 width=0) (actual time=24.424..24.425 rows=1 loops=1) -> Bitmap Heap Scan on test (cost=32.21..2582.55 rows=1000 width=0) (actual time=6.026..15.441 rows=49998 loops=1) Recheck Cond: (test_period @> (now() + '5277:46:40'::interval)) -> Bitmap Index Scan on test_period_idx (cost=0.00..31.96 rows=1000 width=0) (actual time=5.982..5.982 rows=49998 loops=1) Index Cond: (test_period @> (now() + '5277:46:40'::interval)) Total runtime: 24.458 ms (6 rows)


The9 is a graphically polished, interactive, easily customizable, highly modern, fast loading.
The9 is a graphically polished, interactive, easily customizable, highly modern, fast loading.
The9 is a graphically polished, interactive, easily customizable, highly modern, fast loading.
The9 is a graphically polished, interactive, easily customizable, highly modern, fast loading.
The9 is a graphically polished, interactive, easily customizable, highly modern, fast loading.
is a graphically polished, interactive, easily customizable, highly modern, fast loading.
OCT 2015 - JUNE 2016
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean tincidunt sit amet erat malesuada interdum. Aenean sodales dui quis leo fermentum scelerisque.
OCT 2015 - JUNE 2016
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean tincidunt sit amet erat malesuada interdum. Aenean sodales dui quis leo fermentum scelerisque.
OCT 2015 - JUNE 2016
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean tincidunt sit amet erat malesuada interdum. Aenean sodales dui quis leo fermentum scelerisque.
OCT 2015 - JUNE 2016
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean tincidunt sit amet erat malesuada interdum. Aenean sodales dui quis leo fermentum scelerisque.


CancellationTokenSource Objects
A CancellationTokenSource is an object that is used to signal cancellation to a deferred (and
possibly asynchronous) computation.
Any CancellationTokenSource object is in one of three mutually exclusive states: _open_,
_signaled_, or _closed_:
-
A source `s` is open if `s.token.canBeCanceled` is *true*.
-
A source `s` is signaled if `s.token.cancellationRequested` is *true*.
-
A source `s` is closed if it is neither open nor signaled.
CancellationTokenSource Abstract Operations
Cancellation Linking Functions
A cancellation linking function is an anonymous built-in function that has a
[[LinkedTarget]] internal slot.
When a cancellation linking function _F_ is called, the following steps are taken:
1. Assert: _F_ has a [[LinkedTarget]] internal slot whose value is an Object.
1. Let _target_ be _F_.[[LinkedTarget]].
1. Return Invoke(_target_, `"cancel"`, « »).
The `length` property of a cancellation linking function is 0.
CancelCancellationTokenSource ( _source_, _promiseCapability_ )
When the CancelCancellationTokenSource abstract operation is called with arguments
_source_ and _promiseCapability_, the following steps are taken:
1. Assert: IsCancellationTokenSource(_source_) is *true*.
1. Assert: _source_.[[CancellationState]] is `"open"`.
1. Assert: _promiseCapability_ is a PromiseCapability Record or *undefined*.
1. Set _source_.[[CancellationState]] to `"cancellationRequested"`.
1. Perform ! UnlinkCancellationTokenSource(_source_).
1. Let _registrations_ be _source_.[[Registrations]].
1. Set _source_.[[Registrations]] to *undefined*.
1. For each _registration_ in _registrations_, in original insertion order, do
1. Let _handler_ be _registration_.[[CancellationTarget]].
1. Set _registration_.[[CancellationSource]] to *undefined*.
1. Set _registration_.[[CancellationTarget]] to *undefined*.
1. Let _result_ be Call(_handler_, *undefined*, « »).
1. If _result_ is an abrupt completion, perform HostReportErrors(« _result_.[[Value]] »).
1. Return *undefined*.
CloseCancellationTokenSource ( _source_ )
When the CloseCancellationTokenSource abstract operation is called with argument
_source_, the following steps are taken:
1. Assert: IsCancellationTokenSource(_source_) is *true*.
1. Assert: _source_.[[CancellationState]] is `"open"`.
1. Set _source_.[[CancellationState]] to `"closed"`.
1. Perform ! UnlinkCancellationTokenSource(_source_).
1. Let _registrations_ be _source_.[[Registrations]].
1. Set _source_.[[Registrations]] to be *undefined*.
1. For each _registration_ in _registrations_, in original insertion order, do
1. Let _target_ be _registration_.[[CancellationTarget]].
1. If _target_ has a [[LinkedTarget]] internal slot, then
1. Let _linkedTarget_ be _target_.[[LinkedTarget]].
1. Remove _registration_ from _linkedTarget_.[[LinkingRegistrations]].
1. Set _registration_.[[CancellationSource]] to *undefined*.
1. Set _registration_.[[CancellationTarget]] to *undefined*.
1. Return *undefined*.
IsCancellationTokenSource ( _x_ )
The abstract operation IsCancellationTokenSource checks for the CancellationTokenSource
brand on an object.
1. If Type(_x_) is not Object, return *false*.
1. If _x_ does not have a [[CancellationState]] internal slot, return *false*.
1. Return *true*.
UnlinkCancellationTokenSource ( _source_ )
When the UnlinkCancellationTokenSource abstract operation is called with argument
_source_, the following steps are taken:
1. Assert: IsCancellationTokenSource(_source_).
1. Let _linkingRegistrations_ be _source_.[[LinkingRegistrations]].
1. Set _source_.[[LinkingRegistrations]] to *undefined*.
1. If _linkingRegistrations_ is *undefined*, return.
1. For each _registration_ in _linkingRegistrations_, in original insertion order, do
1. Let _source_ be _registration_.[[CancellationSource]].
1. If _source_ is not *undefined*, then
1. Remove _registration_ from _source_.[[Registrations]].
1. Set _registration_.[[CancellationSource]] to *undefined*.
1. Set _registration_.[[CancellationTarget]] to *undefined*.
1. Return.
GetCancellationTokenSourceState ( _source_ )
When GetCancellationTokenSourceState is called with argument _source_, the following steps are
taken:
1. Assert: IsCancellationTokenSource(_source_) is *true*.
1. Let _state_ be _source_.[[CancellationState]].
1. Let _linkingRegistrations_ be _source_.[[LinkingRegistrations]]
1. If _state_ is `"open"` and _linkingRegistrations_ is not *undefined*, then
1. For each _registration_ in _linkingRegistrations_, in original insertion order, do
1. Let _source_ be _registration_.[[CancellationSource]].
1. If _source_ is not *undefined*, then
1. Let _sourceState_ be GetCancellationTokenSourceState(_source_).
1. If _sourceState_ is `"cancellationRequested"`, then
1. Return `"cancellationRequested"`.
1. Return _state_.
The CancellationTokenSource Constructor
The CancellationTokenSource constructor is the %CancellationTokenSource%
intrinsic object and the initial value of the `CancellationTokenSource` property of the
global object. When called as a constructor it creates and initializes a new
CancellationTokenSource object. CancellationTokenSource is not intended to be called as a
function and will throw an exception when used in that manner.
CancellationTokenSource ( [ _linkedTokens_ ] )
When the `CancellationTokenSource` function is called with optional argument
_linkedTokens_, the following steps are taken:
1. If NewTarget is *undefined*, throw a *TypeError* exception.
1. Let _source_ be ? OrdinaryCreateFromConstructor(NewTarget,
`"%CancellationTokenSourcePrototype%"`, « [[CancellationState]], [[Token]],
[[Registrations]], [[LinkingRegistrations]] »).
1. Let _token_ be ? ObjectCreate(%CancellationTokenPrototype%, «
[[CancellationTokenState]], [[CancellationTokenSource]] »).
1. Set _token_.[[CancellationTokenState]] to `"entangled"`.
1. Set _token_.[[CancellationTokenSource]] to _source_.
1. Set _source_.[[CancellationState]] to `"open"`.
1. Set _source_.[[Registrations]] to a new empty List.
1. Set _source_.[[Token]] to _token_.
1. If _linkedTokens_ is not present, let _linkedTokens_ be *undefined*.
1. Else,
1. Let _iter_ be ? GetIterator(_linkedTokens_).
1. If _iter_ is *undefined*, then
1. Set _source_.[[LinkingRegistrations]] to *undefined*.
2. Return _source_.
1. Set _source_.[[LinkingRegistrations]] to a new empty List.
1. Let _handler_ be a new built-in function object as defined in Cancellation Linking
Functions ().
1. Set _handler_.[[LinkedTarget]] to _source_.
1. Repeat,
1. Let _next_ be ? IteratorStep(_iter_).
1. If _next_ is *false*, return _source_.
1. Let _nextItem_ be ? IteratorValue(_next_).
1. If IsCancellationToken(_nextItem_) is *false*, then
1. Let _error_ be Completion { [[Type]]: ~throw~, [[Value]]: a newly created
*TypeError* object, [[Target]]: ~empty~ }.
1. Return ? IteratorClose(_iter_, _error_).
1. Let _linkedState_ be ? GetCancellationTokenState(_nextItem_).
1. If _linkedState_ is `"cancellationRequested"`, then
1. Let _status_ be CancelCancellationTokenSource(_source_).
1. If _status_ is an abrupt completion, return ? IteratorClose(_iter_,
_status_).
1. Return _source_.
1. If _linkedState_ is `"open"`, then
1. Let _linkedSource_ be _nextItem_.[[CancellationTokenSource]].
1. Assert: IsCancellationTokenSource(_linkedSource_) is *true*.
1. Let _registration_ be CreateCancellationRegistration(_linkedSource_,
_handler_).
1. If _registration_ is an abrupt completion, return ? IteratorClose(_iter_,
_registration_).
1. Append _registration_ as the last element of
_linkedSource_.[[Registrations]].
1. Append _registration_ as the last element of
_source_.[[LinkingRegistrations]].
Properties of the CancellationTokenSource Constructor
The value of the [[Prototype]] internal slot of the `CancellationTokenSource` constructor is
the intrinsic object %FunctionPrototype%.
The CancellationTokenSource constructor has the following properties:
CancellationTokenSource.prototype
The initial value of `CancellationTokenSource.prototype` is the intrinsic object
%CancellationTokenSourcePrototype%.
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*,
[[Configurable]]: *false* }.
Properties of the CancellationTokenSource Prototype Object
The CancellationTokenSource prototype object is the intrinsic object
%CancellationTokenSourcePrototype%. The value of the [[Prototype]] internal slot
of the CancellationTokenSource prototype object is the intrinsic object %ObjectPrototype%.
The CancellationTokenSource prototype object is an ordinary object. It does not have the
[[CancellationState]] internal slot or any of the other CancellationTokenSource instance
internal slots.
CancellationTokenSource.prototype.cancel ()
When the `cancel` method is called, the following steps are taken:
1. Let _source_ be the *this* value.
1. If IsCancellationTokenSource(_source_) is *false*, throw a *TypeError* exception.
1. Let _promiseCapability_ be ? NewPromiseCapability(%Promise%)
1. If _source_.[[CancellationState]] is `"open"`, then
1. Perform ? CancelCancellationTokenSource(_source_, _promiseCapability_).
1. Return *undefined*.
CancellationTokenSource.prototype.close ()
When the `close` method is called, the following steps are taken:
1. Let _source_ be the *this* value.
1. If IsCancellationTokenSource(_source_) is *false*, throw a *TypeError* exception.
1. If _source_.[[CancellationState]] is `"open"`, then
1. Perform ? CloseCancellationTokenSource(_source_).
1. Return *undefined*.
CancellationTokenSource.prototype.constructor
The initial value of `CancellationTokenSource.prototype.constructor` is the intrinsic
object %CancellationTokenSource%.
get CancellationTokenSource.prototype.token
`CancellationTokenSource.prototype.token` is an accessor property whose set accessor
function is *undefined*. Its get accessor function performs the following steps:
1. Let _source_ be the *this* value.
1. If IsCancellationTokenSource(_source_) is *false*, throw a *TypeError* exception.
1. Return _source_.[[Token]].
CancellationTokenSource.prototype [ @@toStringTag ]
The initial value of the @@toStringTag property is the String value
`"CancellationTokenSource"`.
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*,
[[Configurable]]: *true* }.
Properties of CancellationTokenSource Instances
CancellationTokenSource instances are ordinary objects that inherit from the
CancellationTokenSource prototype object (the intrinsic %CancellationTokenSourcePrototype%).
CancellationTokenSource instances are initially created with the internal slots described
in .
| Internal Slot |
Description |
| [[CancellationState]] |
A String value indicating the current state of the source. Possible values
include `"open"`, `"cancellationRequested"`, and `"closed"`.
|
| [[Registrations]] |
A List of Cancellation Registration objects registered to this source.
|
| [[Token]] |
A CancellationToken instance entangled with the source.
|
| [[LinkingRegistrations]] |
A List of Cancellation Registration objects that link this source to other
tokens.
|
Cancellation Registration Objects
A Cancellation Registration is an object that provides the capability to unregister a
callback registered to some CancellationToken object. There is not a named constructor for
Cancellation Registration objects. Instead, Cancellation Registration objects are created by
calling certain methods of CancellationToken instance objects.
CreateCancellationRegistration ( _source_, _target_ )
When CreateCancellationRegistration is called with arguments _source_ and _target_ the
following steps are taken:
1. Assert: IsCancellationTokenSource(_source_) is *true*.
1. Assert: IsCallable(_target_) is *true*.
1. Let _registration_ be ? ObjectCreate(%CancellationRegistrationPrototype%, «
[[CancellationSource]], [[CancellationTarget]] »).
1. Set _registration_.[[CancellationSource]] to be _source_.
1. Set _registration_.[[CancellationTarget]] to be _target_.
1. Return _registration_.
IsCancellationRegistration ( _x_ )
The abstract operation IsCancellationRegistration checks for the registration brand on
an object.
1. If Type(_x_) is not Object, return *false*.
1. If _x_ does not have a [[CancellationSource]] internal slot, return *false*.
1. Return *true*.
The %CancellationRegistrationPrototype% Object
The %CancellationRegistrationPrototype% object is an orderinary object and
its [[Prototype]] internal slot is the %ObjectPrototype% intrinsic object. In addition,
%CancellationRegistrationPrototype% has the following properties:
%CancellationRegistrationPrototype%.unregister ()
When the `unregister` method is called, the following steps are taken:
1. Let _registration_ be the *this* value.
1. If IsCancellationRegistration(_registration_) is *false*, throw a *TypeError*
exception.
1. Let _source_ be _registration_.[[CancellationSource]].
1. If _source_ is *undefined*, return.
1. Remove _registration_ from _source_.[[Registrations]].
1. Set _registration_.[[CancellationSource]] to be *undefined*.
1. Set _registration_.[[CancellationTarget]] to be *undefined*.
%CancellationRegistrationPrototype% [ @@toStringTag ]
The initial value of the @@toStringTag property is the String value
`"CancellationToken Registration"`.
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*,
[[Configurable]]: *true* }.
Properties of Cancellation Registration Instances
Cancellation Registration instances are ordinary objects that inherit properties from
the %CancellationRegistrationPrototype% intrinsic object. Cancellation Registration
instances are initially created with the internal slots listed in
.
| Internal Slot |
Description |
| [[CancellationSource]] |
The CancellationTokenSource to which this registration is associated.
|
| [[CancellationTarget]] |
A Function object to execute or a linked CancellationTokenSource to cancel
when cancellation is requested.
|


[gecode-users] Lower bound for Branch-and-bound
Mikael Zayenz Lagerkvist
zayenz at gmail.com
Tue Apr 5 10:05:30 CEST 2011
2011/4/5 Jonathan Skovhus Andersen <jonathanskovhus at gmail.com>
> I have read the documentation, but the 2 pages describing the circuit
> constraint seems quite inadequate to me.
>
Looking at the source code (gecode/graph/circuit.cpp) shows that the cost
variant of circuit currently uses linear to compute the total cost. This
will not give a very good quality bound, since the computation does not use
the fact that the costs come from a circuit.
But anyway. The main problem I have is that I am dealing with problems where
> it is not feasible to let the BAB search finish. Then I would like to
> estimate how close this solution is to the optimum solution. Do you know if
> there is any quick way to do this or do I have to implement my own
> calculations of a lower bound to compare my solution to?
>
My guess would be that a custom estimator is probably worth it, given that
there is something reasonable to implement. I haven't looked into this
though. Anybody else know anything?
In general, for pure TSP problems I don't believe that CP is the best
technology choice. You might have interesting side-constraints though?
Cheers,
Mikael
--
Mikael Zayenz Lagerkvist, http://www.ict.kth.se/~zayenz/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.gecode.org/pipermail/users/attachments/20110405/a1f95ccc/attachment.htm>
More information about the users
mailing list


{% extends 'layout.html' %} {% block pageTitle %} NHS.UK prototype kit {% endblock %} {% block beforeContent %} {% endblock %} {% block content %}
Chickenpox is common and mostly affects children, although you can get it at any age. It usually gets better by itself within a week without needing to see a GP.
An itchy spotty rash is the main symptom of chickenpox.
New spots might appear while others are becoming blisters or forming a scab.
Before or after the rash appears, you might also get:
Chickenpox can make children feel miserable, even if they do not have many spots.
Chickenpox is usually much worse in adults.
It's possible to get chickenpox more than once, although it's unusual.
Check other rashes in children.
You'll need to stay away from school, nursery or work until all the spots have crusted over.
This is usually 5 days after the spots appeared.
drink plenty of fluid (try ice lollies if your child is not drinking) to avoid dehydration
take paracetamol to help with pain and discomfort
put socks on your child's hands at night to stop scratching
cut your child's nails
use cooling creams or gels from a pharmacy
speak to a pharmacist about using antihistamine medicine to help itching
bathe in cool water and pat the skin dry (do not rub)
dress in loose clothes
check with your airline if you're going on holiday – many airlines will not allow you to fly with chickenpox
do not use ibuprofen unless advised to do so by a doctor, as it may cause serious skin infections
do not give aspirin to children under 16
do not be around pregnant women, newborn babies and people with a weakened immune system, as chickenpox can be dangerous for them
Tell the receptionist you think it's chickenpox before going in.
They may recommend a special appointment time if other patients are at risk.
It's still important to get help from a GP if you need it. To contact your GP surgery:
You may need medicine to prevent complications. You need to take it within 24 hours of the spots appearing.
111 will tell you what to do. They can arrange a phone call from a nurse or doctor if you need one.
Go to 111.nhs.uk or call 111.
You can catch chickenpox by being in the same room as someone with it. It's also spread by touching clothes or bedding that has fluid from the blisters on them.
Chickenpox is infectious from 2 days before the spots appear, until they have all crusted over – usually 5 days after they first appeared.
It takes 1 to 3 weeks from the time you were exposed to chickenpox for the spots to start appearing.
It's rare to get chickenpox when you're pregnant, and the chance of it causing complications is low.
If you do get chickenpox when you're pregnant, there's a small risk of your baby being very ill when it's born.
Speak to a GP if you have not had chickenpox and have been near someone with it.
You can get the chickenpox vaccine on the NHS if there's a risk of harming someone with a weakened immune system if you spread the virus to them.
For example, a child can be vaccinated if 1 of their parents is having chemotherapy.
You can also pay for the vaccine at some private clinics or travel clinics. It costs between £120 and £200.
You cannot catch shingles from someone with chickenpox.
You can catch chickenpox from someone with shingles if you have not had chickenpox before.
When you get chickenpox, the virus stays in your body. The virus can be triggered again if your immune system is weak. This cause shingles.
This can happen because of stress, certain conditions, or treatments like chemotherapy.


Workers
ID
Name
Surname
Email
Street Address
City
Country
Phone Number
Password
Job
Admin
Enter new worker data
×
First Name:
Last Name:
Email address
We'll never share your email with anyone else.
Address:
City:
Country:
Phone number:
Password:
Job:
Admin
Choose your option
YES
NO
Enter worker data
×
First Name:
Last Name:
Email address
We'll never share your email with anyone else.
Address:
City:
Country:
Phone number:
Password:
Job:
Admin
Choose your option
YES
NO


Sam Ritchie
archive
about
projects
race results
{{ content }} {% if page.comments %}
Please enable JavaScript to view the
comments powered by Disqus.
blog comments powered by
Disqus
{% endif %}


|
SWE_FVM
1.0.0
|
#include <MUSCLObject.h>
Classes | |
| struct | MUSCL |
Public Member Functions | |
| VolumeField & | GetVolField () noexcept |
| const VolumeField & | GetVolField () const noexcept |
| const Bathymetry & | Bath () const noexcept |
| const TriangMesh & | Mesh () const noexcept |
| bool | IsDryCell (Idx i) const |
| bool | IsFullWetCell (Idx i) const |
| bool | IsPartWetCell (Idx i) const |
Protected Member Functions | |
| MUSCLObject (Bathymetry &&b, const VolumeField &v0) | |
| MUSCLObject (Bathymetry &&b, VolumeField &&v0) | |
| MUSCL | ReconstructDryCell (Idx i) const |
| MUSCL | ReconstructFullWetCell (Idx i) const |
| MUSCL | ReconstructPartWetCell1 (Idx i) const |
| MUSCL | ReconstructPartWetCell2 (Idx i) const |
Protected Attributes | |
| Bathymetry | m_b |
| VolumeField | m_vol |
| Storage< 1 > | m_max_wp |
|
protected |
|
protected |
|
inlinenoexcept |
|
inlinenoexcept |
|
inlinenoexcept |
| bool MUSCLObject::IsDryCell | ( | Idx | i | ) | const |
| bool MUSCLObject::IsFullWetCell | ( | Idx | i | ) | const |
| bool MUSCLObject::IsPartWetCell | ( | Idx | i | ) | const |
|
inlinenoexcept |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |


--- title: Home disable_breadcrumbs: true disable_in_breadcrumbs_trail: true ---
Powered by API Umbrella, an open-source API management platform.


Arrays and Hashes
Arrays are ordered lists in which you can store a number of values inside a single variable. This will be an indexed list starting from index 0.
For example, lets define a simple array of integers:
demoArray = [4,33,6,544,66,0,9]
demoArray[0] will give us access to integer 4
demoArray[3] will give us access to integer 544
demoArray[6] will give us access to integer 9
Similarly, an array can hold string values as well as mixed values.
mixArray = ["Hello", 34, 8.6, "there"]
Hash is an unorderd list, and has key-value pairs. While in array you can access any element using the index number, in a hash you can access the value of the element through the key. You can think of hashes as a way of mapping one value to the another.
For example, lets define a hash containg owner and pets as key value pairs:
newHash = {
'Steve' => 'dog',
'Harinder' => 'cat',
'Sarah' => 'horse'
}
newHash['Steve'] will give is access to value 'dog'
We can also use symbols as hash keys, which makes the retrieving of values faster and hence, increase the efficiency of the program. For example:
myHash = {
:Harry => 'owl'
}


Scripts
You can bundle executable files within your package and Installer.app will run these executables during the install. Generally these files will be shell scripts.
In a built package, scripts are stored in the Contents/Resources/
directory of your package and must have their executable bit set. When building a package, scripts and all other resources should be placed in the Install_resources
directory or your root. This directory can be specified in the “Scripts” tab of the PackageMaker user interface.
Installation scripts run during the actual installation of your package. Installer.app looks for scripts with specific names at certain times. You should use the following names for your scripts:
preflight
: Executed before the installation process.postflight
: Executed after the installation process.preinstall
: Executed before installing a single package. Not executed during an upgrade.postinstall
: Executed after installing a single package. Not executed during an upgrade.preupgrade
: Executed before upgrading a single package. Not executed during an install.postupgrade
: Executed after upgrading a single package. Not executed during an install.
Arguments
Installer.app provides the following arguments:
$1
: The full path to the installation package.$2
: The full path to the installation destination.$3
: The mountpoint of the destination volume.$4
: The root directory for the current System folder.
Environment Variables
In addition to arguments, Installer.app sets some Environment variables:
$INSTALLER_TEMP
: The scratch area used by Installer.app for temporary work. Executable files may write to this directory, but must not overwrite Installer files. Available to preinstall, preupgrade, postflight, postupgrade, and postinstall.$PACKAGE_PATH
: Same as the $1 argument. Available to preinstall, preupgrade, postfight, and postupgrade.$RECEIPT_PATH
: The full path to the directory containing the file being executed. This is a location to which the package has been copied. The executable can currently use this path to locate other files in the package, but this may change in the future. Available to postflight, postupgrade, and postinstall.$SCRIPT_NAME
: The name of the file being executed. Available to postflight, postupgrade, and postinstall.$TMPDIR
: This variable is set when the user is doing a Net or CD installation, but is not set when the user is running on a local writable file system. If set, it contains a path to a location on a writable destination volume. Available to preinstall, preupgrade, postflight, postupgrade, and postinstall.
An Example
#!/bin/bash # # This postflight script echoes the values of the available # arguments and environmental variables. # echo "Start postflight script" echo "" echo "Arguments:" echo "" echo "\$1: full path to the installation package" echo " $1" echo "\$2: full path to the installation destination" echo " $2" echo "\$3: mountpoint of the destination volume" echo " $3" echo "\$4: root directory \"/\" for the current System folder" echo " $4" echo "" echo "Environment variables available to a postflight executable:" echo " INSTALLER_TEMP, PACKAGE_PATH, RECEIPT_PATH, SCRIPT_NAME, and TMPDIR" echo "" echo "\$INSTALLER_TEMP: scratch area used by Installer for temporary work files" echo " $INSTALLER_TEMP" echo "" echo "\$PACKAGE_PATH: full path to the installation package; should be same as \$1" echo " $PACKAGE_PATH" echo "" echo "\$RECEIPT_PATH: full path to directory containing the file being executed" echo " $RECEIPT_PATH" echo "" echo "\$SCRIPT_NAME: name of the file being executed" echo " $SCRIPT_NAME" echo "" echo "\$TMPDIR: if set, a path to a location on a writable destination volume" echo " $TMPDIR" echo "" echo "End postflight script" exit 0


[next] [prev] [prev-tail] [tail] [up]
time = psb_wtime()
This function returns a wall clock timer. The resolution of the timer is dependent on the underlying parallel environment implementation.
[next] [prev] [prev-tail] [front] [up]


com.cyc.kb.spi
Interfaces
AssertionService
BinaryPredicateService
ContextService
FactService
FirstOrderCollectionService
KbApiService
KbCollectionService
KbFunctionService
KbIndividualService
KbPredicateService
KbService
KbTermService
RelationService
RuleService
SecondOrderCollectionService
SentenceService
SymbolService
VariableService


Motivatix
Search for famous people and see what is behind their success.
Motivatix © 2014-2015 ::
About project & team


Camera with a REST interface
06 Dec 2015I’ve written a few versions of this. In previous versions I would control everything from a Python prompt, or a complex flask app, or use DIO to trigger video.
In this version I am trying to keep it simple and starting/stopping video and timelapse images with a REST api.
To test this out, I will have a motion sensor on another Pi send a REST command to start video when it senses motion.
VideoServer.py is using a circular stream such that when recording is started, it also saves ‘pre-triggered’ video before recording was started. It can also capture timelapse images while it is recording video. The Raspberry camera is very nice for these two features. I’ve written VideoServer as a class inheriting from threading.Thread so it can run daemonized as a background thread, otherwise it will block other code.
- VideoServer.py, controls the camera with the following interface:
- startArm(), initializes the camera.
- stopArm(), release the camera.
- startVideo(), starts video recording.
- stopVideo(), stops video recording
- doTimelapse=1, starts acquiring timelapse images
- doTimelapse=0, stops acquiring timelapse images
- timelapse_app.py, starts a flask webserver which provides a REST api as a wrapper around VideoServer.py:
http://<IP_ADDRESS>:5010/startarm
http://<IP_ADDRESS>:5010/stoparm
http://<IP_ADDRESS>:5010/startvideo
http://<IP_ADDRESS>:5010/stopvideo
http://<IP_ADDRESS>:5010/timelapseon
http://<IP_ADDRESS>:5010/timelapseoff
http://<IP_ADDRESS>:5010/lastimage
To Do: I still need to expose ‘bufferSeconds’ and ‘stillinterval’ to the REST API.
Get the last timelapse image in a browser or with curl
# display in browser
http://<IP_ADDRESS>:5010/lastimage
# save from command line
curl -o http://<IP_ADDRESS>:5010/lastimage
rsync the images and video to a remote host
Now I want to get the videos/images off the machine with the camera. There are more options than I can count but here are three:
- Push the recorded video/images to another server from within Python/Flask. I’ve done this before with Paramiko but have always had problems with the code hanging or exceptions thrown when a network connection is lost.
- Have another machine (also running flask) pull the images off the camera machine. This can be done with the /lastimage REST path. This requires the other machine to be running server code itself and to have some sort of timer.
- Use rsynch on the machine running the camera to a push videos/images to a remote server and use cron to do this at a regular interval.
I will use rsynch to push the images to a remote server. Follow this for a really thorough explanation.
# assuming you have a folder 'securitycam' on remote host
rsync -avz /home/pi/video/20151206/ -e ssh cudmore@<IP_ADDRESS>:securitycam
Make sure you can login to remote server without entering a password
add this
Run rsynch command every 10 minutes with crontab
crontab -e
*/10 * * * * /usr/bin/rsync -avz /home/pi/video/20151206/ -e ssh cudmore@<IP_ADDRESS>:securitycam


The database interface layer is a simple abstract class that provides read, insert, update, delete and scan operations for your database. Implementing a database interface layer for your database means filling out the body of each of those methods. Once you have compiled your layer, you can specify the name of your implemented class on the command line (or as a property) to the YCSB Client. The YCSB Client will load your implementation dynamically when it starts. Thus, you do not need to recompile the YCSB Client itself to add or change a database interface layer.
The YCSB Client framework will create one instance of your DB class per worker thread, but there might be multiple worker threads generating the workload, so there might be multiple instances of your DB class created.
public void init() throws DBExceptionto perform any initialization actions. The init() method will be called once per DB instance; so if there are multiple threads, each DB instance will have init() called separately.
The init() method should be used to set up the connection to the database and do any other initialization. In particular, you can configure your database layer using properties passed to the YCSB Client at runtime. In fact, the YCSB Client will pass to the DB interface layer all of the properties specified in all parameter files specified when the Client starts up. Thus, you can create new properties for configuring your DB interface layer, set them in your parameter files (or on the command line), and then retrieve them inside your implementation of the DB interface layer.
These properties will be passed to the DB instance after the constructor, so it is important to retrieve them only in the init() method and not the constructor. You can get the set of properties using the
public Properties getProperties()method which is already implemented and inherited from the DB base class.
//Read a single record public int read(String table, String key, SetIn each case, the method takes a table name and record key. (In the case of scan, the record key is the first key in the range to scan.) For the read methods (read() and scan()) the methods additionally take a set of fields to be read, and provide a structure (HashMap or Vector of HashMaps) to store the returned data. For the write methods (insert() and update()) the methods take HashMap which maps field names to values.fields, HashMap result); //Perform a range scan public int scan(String table, String startkey, int recordcount, Set fields, Vector > result); //Update a single record public int update(String table, String key, HashMap values); //Insert a single record public int insert(String table, String key, HashMap values); //Delete a single record public int delete(String table, String key);
The database should have the appropriate tables created before you run the benchmark. So you can assume in your implementation of the above methods that the appropriate tables already exist, and just write code to read or write from the tables named in the "table" parameter.
% java -cp build/ycsb.jar:yourjarpath com.yahoo.ycsb.Client -t -db com.foo.YourDBClass -P workloads/workloada -P large.dat -s > transactions.datYou can also specify the DB interface layer using the DB property in your parameter file:
db=com.foo.YourDBClass


Delete ${customer.id}
ID
Email
Description
${customer.id}
${customer.email}
${customer.description}
Delete profile


House Images
Bottom Nav
The History of the Game Of Thrones Houses. Click a House to Begin.
x
Controls


--- layout: example categories: example/v1.0.0 version: v1.0.0 title: Movetip description: Open a tooltip just above gridLayer interactivity as a cursor moves. tags: - ui - tilemill ---


|
Pebble Foundation Classes
0.2.0
C++ for Pebble
|
Layer that is automatically managed. More...
#include <pebble_layer.hpp>
Public Member Functions | |
| SimpleLayer (GRect frame) | |
| virtual | ~SimpleLayer () |
| Destroys the underlying AppLayer. | |
| Public Member Functions inherited from Pebble::Layer | |
| Layer (::Layer *layer) | |
| Wraps an existing TextLayer. | |
| operator::Layer * () | |
| Instances of this class can be automatically converted to Pebble Layers. | |
| operator const ::Layer * () const | |
| void | MarkDirty () |
| void | SetFrame (GRect frame) |
| void | SetFrame (int16_t x, int16_t y, int16_t w, int16_t h) |
| void | SetFrame (GPoint origin, GSize size) |
| GRect | GetFrame () |
| void | SetBounds (GRect bounds) |
| GRect | GetBounds () |
| void | RemoveFromParent () |
| void | RemoveChildLayers () |
| void | AddChild (Layer &child) |
| void | InsertBelowSibling (Layer &below_sibling_layer) |
| void | InsertAboveSibling (Layer &above_sibling_layer) |
| void | SetHidden (bool hidden) |
| bool | GetHidden () |
| void | SetClips (bool clips) |
| bool | GetClips () |
Static Protected Member Functions | |
| static SimpleLayer & | GetFromData (::Layer *layer) |
Additional Inherited Members | |
| Protected Attributes inherited from Pebble::Layer | |
| ::Layer * | layer_ |
Layer that is automatically managed.
This subclass of layer creates and destroys the underlying Pebble OS layer structure automatically. This type of layer should be used as a container for other layers but does not do any drawing on it's own.
|
inline |
Creates a layer and sets its frame and bounds. Default values:
bounds
: origin (0, 0) and a size equal to the frame that is passed in.clips
: true
hidden
: false
| frame | The frame at which the layer should be initialized. |
|
inlinestaticprotected |
Given a pebble layer returns reference to the layer class
| layer | Pebble lawyer |


{{ page.title }}
Notes mentioning this note
{% if page.backlinks.size > 0 %}
{% for backlink in page.backlinks %}
{% endfor %}
{% else %}
There are no notes linking to this note.
---
layout: default
---
There are no notes linking to this note.
{{ page.title }}
Notes mentioning this note
{% if page.backlinks.size > 0 %}
{% for backlink in page.backlinks %}
{% endfor %}
{% else %}
{% endif %}
Here are all the notes in this garden, along with their links, visualized as a graph.
{% include notes_graph.html %}


This inspection highlight import statements references a module which is deprecated in current Python version.


| The first letter of the answer is in the word PUZZLE. | The last letter of the answer appears in the title. | The third letter of the answer is a consonant. | This circuit outputs 1. | Gigabytes and gibibytes are the same size according to the International Electrotechnical Commission. | _ _ | |||
| The answer has fewer letters than the title. | Quick-break technology, which the modern light switch is based on, was patented in 1884. | The Binary is an office building in Cairo, Egypt. | The first letter of the answer has exactly one enclosed space when written as a capital letter. | Ammonium chloride is a binary compound. | P ⊆ NP | _ _ _ _ | ||
| The first version of what would become JavaScript was written in ten days. | The first three letters of the answer form a valid English word. | The penultimate letter of the answer is in the word BOXLIKE. | Huffman coding is a method of creating an optimal prefix code. | Charles Babbage never completed a working version of his Analytical Engine. | It is possible to write both eight and negative eight in two's complement form using only four bits each. | _ _ _ _ | ||
| The length of the answer is divisible by two. | The answer is playable in a game of English Scrabble. | The last letter of the answer is one of the 18 least frequent letters in the English language. | Stuxnet was a cyberattack designed to damage equipment of the Iranian Nuclear Program. | The length of the answer is divisible by three. | The penultimate letter of the answer is a consonant. | _ | ||
| ENIAC was decommissioned a little less than 10 years after its first practical use. | The Python programming language is named after the snake. | The last letter of the answer is not in the word TRUE. | Binary fission is a form of sexual reproduction. | The second letter of the answer has an enclosed space when written as a capital letter. | Ada Lovelace published the first computer algorithm in Notes. | _ _ _ _ | ||
| The Dog Star is actually a binary star system. | Boolean algebra was first introduced in Gödel, Escher, Bach, an Eternal Golden Braid. | The word 'byte' came about because of a misspelling in an internal missive. | AVL trees and red-black trees are both types of binary trees. | The binary search algorithm performs at least n^2 operations in the worst case, where n is the number of elements in the array being searched. | The third letter of the answer is in the first six letters of the English alphabet. | _ _ _ _ _ | ||
| The last letter of the answer has exactly one enclosed space when written as a capital letter. | A false dichotomy is the reduction of a situation to two options, when other options exist. | C# was called "Cool" (C-like Object Oriented Language) prior to being named C#. | 01010100 01010010 01010101 01000101 | A provably secure hash function is an example of a one-way function. | _ _ _ _ | |||
| The number of vowels in the answer is even. | The last letter of the answer has exactly one enclosed space when written as a capital letter. | The second letter of the answer has a curved stroke when written as a capital letter. | The penultimate letter of the answer is usually written without lifting the pencil in lower case. | The first letter of the answer is not adjacent to a vowel in the alphabet. |


Relocate your asset root¶
When you install Google Earth Enterprise, you configure a source
volume and asset root for your production data. If you accepted
the default values, they are /gevol/src
and /gevol/assets
,
respectively.
You may need to relocate your asset root to a different volume for a variety of reasons. You may be migrating from a single- to a multiple-workstation configuration or modifying the local path of a network-mounted source volume (for example, when adding a larger drive for source data).
Note
Your asset root and publish root,
/published_dbs/
, should be located on the same volume,
enabling Fusion to use symbolic links. Keeping your asset root
and publish root on separate volumes causes Fusion to make
copies of your databases, obviously leading to greater use of
disk space.
Relocate your asset root and publish root
To relocate your asset root and publish root:
Copy your asset root to the new location.
Select your new asset root:
sudo /opt/google/geselectassetroot --assetroot new_path
You may need to repair the relocated asset root, fixing various inconsistencies in the asset root (such as permissions, ownership, missing ID files, etc.). When you run this command, the tool auto-detects the problems that need to be repaired and fixes them.
sudo /opt/google/bin/geconfigureassetroot --repair new_path
Tip
You may relocate/change other volume settings by editing volumes. You can add a volume to the selected asset root, modify the localpath definition for an existing volume, or add a volume definition:
sudo /opt/google/bin/geconfigureassetroot --editvolume
Tip
Make sure that the update to the asset root is successful before attempting further changes to volume settings.
Run Fusion and verify that you see all your databases.
Create your new publish root:
sudo /opt/google/bin/geconfigurepublishroot
Once you have configured the new publish root, you must republish all of the databases, by pushing and then publishing them. You can use the Fusion GUI to push and the GEE Server Admin console to publish your databases or you can perform these steps on the command line:
geserveradmin -adddb
geserveradmin -pushdb
geserveradmin -publishdb
Optionally, you can delete your old asset root and your publish root.
Relocate your asset root only
Your asset root and publish root, /published_dbs/
, should be
located on the same volume, enabling Fusion to use symbolic links.
If you maintain your asset root and publish root on separate
volumes, Fusion makes copies of your databases, obviously leading
to greater use of disk space.
To relocate your asset root if your publish root will not be on the same volume:
Unpublish all databases on the Databases page of the GEE Server Admin console or on the command line:
geserveradmin --unpublish target_path
Delete all pushed databases:
geserveradmin --deletedb db_name
Clean up deleted databases using
garbagecollect
. This is equivalent to emptying the Trash on some operating systems.geserveradmin --garbagecollect
Copy the asset root to the new location.
Select the new asset root:
sudo /opt/google/geselectassetroot --assetroot new_path
You may need to repair the relocated asset root, fixing various inconsistencies in the asset root (such as permissions, ownership, missing ID files, etc.). When you run this command, the tool auto-detects the problems that need to be repaired and fixes them.
sudo /opt/google/bin/geconfigureassetroot --repair new_path
Run Fusion and verify that you see all of the databases.
Once you have configured the new publish root, you must republish all your databases, by pushing and then publishing them. You can use the Fusion GUI to push and the GEE Server Admin console to publish your databases or you can perform these steps on the command line:
geserveradmin -adddb
geserveradmin -pushdb
geserveradmin -publishdb
Optionally, you can delete your old asset root.
Learn more


Recipes (163)
Apple Muffins
Apple Stuffed Chicken Breast
Asian Lettuce Wraps
Asian Orange Chicken
Baby Back Ribs
Balsamic-Glazed Pork Chop Dinner
Banana Bread
Banana Chocolate Chip Muffins
Beef and Broccoli
Beef Lo Mein
Best Hamburger Ever
Best Steak Marinade in Existence
Blackberry BBQ Sauce
Blackberry Cobbler
Blueberry Muffins
Blueberry Syrup
Boxed Chocolate Cupcake
Brownies
Butter Beer
Caesar Dessing
Cafe Style Grilled Chicken Sandwiches
Carbonara
Carrot Cake
Challenge Muffin
Chewy Chocolate Chunk Cookies
Chicken and Rice Casserole with Almond Milk
Chicken Costa Brava
Chicken Enchiladas
Chicken Kabobs
Chicken Pot Pie
Chicken Salad
Chicken Teriyaki
Chicken-Rotisserie Style
Chocolate Almond Butter Bark with Pretzels
Chocolate Banana Muffins
Chocolate Cake
Chocolate Chip Muffins (Egg)
Chocolate Chip Shortbread Cookies
Chocolate Chip, Oatmeal, and Nut Cookies
Chocolate Crinkle Cookies
Chocolate No Bake Cookies
Cinnamon Rolls
Classic Dinner Rolls
Classic Macaroni Salad
Cocoa Mints
Corn Chowder
Corn Dogs
Cranberry Sauce
Cream of Mushroom
Creamy Vegan Lemon Asparagus Pasta
Creepy Cookie Cake
Daiquiri
Dairy-Free Clam Chowder
Dairy-Free Fettuccine Alfredo
Dairy-Free Hot Fudge Sauce
Double Chocolate Caramel Marshmallow Brownies
Double Chocolate Cookies
Easy Goulash
Easy Meatballs
Easy Meatloaf
Easy Sour Cream Chip Dip
Easy Vegan Nacho Cheese Sauce
Easy Vegan Pumpkin Pie
Egg Replacer
Egg-Free Crepes
Eggless Chocolate Chip Muffins Recipe (Vegan)
Eggless Chocolate Chipit Snackin' Muffins
Eggless Chocolate Lava Cake
Emily's Famous Hash Browns
Empire Cookies
English Muffins
French Dip Sandwiches
French Toast
Fried Bologna Sandwich
Fried Chicken Strips
Fried Rice (No Eggs)
Frosted Pumpkin Muffins
Gooey Caramel Monkey Bread
Green Bean Casserole
Grilled Salmon
Homemade Cherry Poptarts with a Plant-Made Crust
Homemade Marshmallow Fluff
Homemade Soft Pretzels
Honey Garlic Pork Chops
Honey Roasted Barbeque Sauce
Hot Sandwiches
Ice Cream Cake
Kettle Corn
Key Lime and Blackberry Mini Pies
Lasagna
Lemon Bars
Mac ‘N’ Cheese in a Mug
Make-Ahead Slow-Cooker Asian Peach Chicken Thighs
Mongolian Beef
Mongolian Beef and Spring Onions
No-Cream Pasta Primavera
One-Pan Stir-Fry 3 Ways
Penne with Sun-Dried Tomato Pesto
Pizza Dough
Plant-Made Mini Pot Pies
Pot Stickers (Chinese Dumplings)
Pretzel Dogs
Pumpkin Bread
Pumpkin Cookies
Quick and Easy Chicken Noodle Soup
Rainbow Pasta Salad I
Rainbow Sprinkle Cinnamon Rolls
Ranch Dip
Red Rooster
Rosemary Pork Roast with Carrots
Simple Homemade Chicken Ramen
Sloppy Joes
Slow Cooker Asian Turkey and Vegetables
Slow Cooker Balsamic-Ginger Chicken Lettuce Cups
Slow Cooker Beef & Broccoli
Slow Cooker Chicken and Noodles
Slow Cooker Chicken Stroganoff Pot Pie
Slow Cooker French Dip Sandwiches
Slow Cooker Garlic Pork Roast
Slow Cooker Pulled Pork
Slow Cooker Sloppy Joes
Slow Cooker Swiss Steak Supper
Slow Cooker Teriyaki Chicken Wings
Slow Cooker Teriyaki-Sesame-Chicken Wraps
Slow Cooker Upside-Down Chicken Pot Pie
Slow-Cooker Cinnamon Roll Pancake
Snickerdoodles
Spaghetti with Marinara Sauce
Spiced Cranberry Punch
Spiral-Cut Hotdogs
Steak
Steak & Grilled Peaches
Strawberry Oatmeal Breakfast Smoothie
Super Soy Chicken Tenders
Taco Pie
Tacos
The Best Damn Vegan Brioche Doughnut (with a Vanilla Glaze and Aquafaba)
The Best Ever Vegan Brownies
The Best Raspberry Bread
The Best Vegan Sugar Cookies
The Easiest and Cheesiest Vegan Fondue
The Ultimate Pancakes
This Vegan Chocolate Lava Cake Is for Die Hard Sweet Tooths
Toffee Bars
Traditional Gyro Meat
True Texas Chili
Turkey Pita Pockets
Vanilla Wafers
Vegan Broccoli Cheese Soup
Vegan Brownies
Vegan Cashew Ricotta Stuffed Shells
Vegan Chocolate Chip Cookies
Vegan Chocolate Mousse
Vegan Chocolate Mousse (Aquafaba)
Vegan Coleslaw
Vegan Doughnuts
Vegan Goldfish Crackers
Vegan Mushroom Ravioli
VEGAN SNICKERDOODLES – SOFT AND PUFFY!
Vegan Thousand Island Dressing
Whipped Almond Ricotta (5 Ingredients!)
Winner Winner Chicken Orzo Dinner
Yummy Fruit Salad


Preparation time
less than 30 mins
Cooking time
over 2 hours
Serves
Serves 6
For this recipe I have used lamb fore shanks, taken from the front leg. I find a whole leg shank tends to be too much for one person, whereas a fore shank, being smaller, provides the perfect amount. Ask your butcher for these if you can’t find them in the supermarket.
Preheat the oven to 160C/140C Fan/Gas 3.
Heat 2 tablespoons of the oil in a deep, ovenproof frying pan or flameproof casserole dish and brown the lamb shanks all over on a high heat for 5–6 minutes or until golden-brown. Remove with a slotted spoon and set aside.
Add the remaining oil and the onion and garlic and fry over a medium heat for 3–4 minutes until soft. Measure the flour into a bowl, pour in the wine and whisk into a smooth paste. Add the stock to the onions, then add the wine and flour mixture and, stirring continuously, bring to the boil. Add the redcurrant jelly and rosemary and stir until thickened.
Place the browned lamb back in the pan, season with salt and pepper, then cover with a lid and transfer to the oven to cook for about 2 hours or until the lamb is tender and just falling off the bone.
When ready to serve, bring a saucepan of salted water to the boil, add the carrots, parsnips and turnips and boil for 8–10 minutes or until tender. Drain.
Add a third of the vegetables to the lamb casserole and stir. Melt a knob of butter in a frying pan and fry the remaining vegetables over a high heat for 4–5 minutes or until golden-brown. Season with salt and pepper and remove from the hob.
Serve one fore shank per person with some of the sauce and vegetables from the casserole and extra fried vegetables on the side. Garnish with the chopped parsley to finish.
You need JavaScript to view this clip.
Browning meat


This text is displayed if your browser does not support HTML5 Canvas.
Stop
verticleFovDeg
cameraPosX
cameraPosY
cameraPosZ


Bitcoin Bowl 101
Step 1: Download the Airbitz wallet:
Simply Secure, Private & Powerful
Learn more
Step 2: Buy some Bitcoin
The
Fastest
Way to Buy Bitcoin
Create your account
in just seconds.
Add your Visa or MasterCard
in less than a minute.
Buy and receive your
bitcoin immediately!
Go to Trucoin
Or, buy Bitcoin in person at these locations:
Step 3: Find somewhere to spend your Bitcoin:
Example Business #1
Example Business #2
Example Business #3
Example Business #4
Find more at the Airbitz directory:
Powered by:
Step 4: Share the #BitcoinBowl on social media to get free Bitcoin
Brought to you by:
Tweet #BitcoinBowl
Step 5: Learn more about Bitcoin online
Read about the basics at:
Catch up on the latest news at:


Library: Foundation
Package: Filesystem
Header: Poco/DirectoryIteratorStrategy.h
Inheritance
Known Derived Classes: ChildrenFirstTraverse, SiblingsFirstTraverse
Member Summary
Member Functions: isDirectory, isFiniteDepth
Types
DepthFunPtr
typedef std::pointer_to_unary_function < const Stack &, UInt16 > DepthFunPtr;
Stack
typedef std::stack < DirectoryIterator > Stack;
Enumerations
Anonymous
D_INFINITE = 0
Special value for infinite traverse depth.
Constructors
TraverseBase
TraverseBase(
DepthFunPtr depthDeterminer,
UInt16 maxDepth = D_INFINITE
);
Member Functions
isDirectory
bool isDirectory(
Poco::File & file
);
isFiniteDepth
bool isFiniteDepth();
Variables
_depthDeterminer
DepthFunPtr _depthDeterminer;
_itEnd
DirectoryIterator _itEnd;
_maxDepth
UInt16 _maxDepth;


Welcome to Life on Mars! This site will allow you to view the Martian weather from a span of five days. This data is periodically updated. The date selector below allows you to retrieve photos taken by one of the Mars rovers on that date.
| Day 1 | Day 2 | Day 3 | Day 4 | Day 5 |
|---|---|---|---|---|


Founder and CTO of Augmented Construction Inc.
I am a machine learning and AI specialist consulting in the architecture and construction industry. My work includes automating clash detection and buildability analysis in building information modeling.
I have 15 years in the construction industry, am a though leader in using technology to improve operational intellgence, and previously led the transition to cloud based paperless workflow as head of the engineering department of a contractor.
I am a Registered Architect in the state of New York.
Email Me
|


You can also author content in raw HTML if that's your flavoring. Gatsby handles that just fine.
some more html, do you remember that?
gotta refresh page tho, from save in this file


Hi, My name is Amandeep. I am self motivated Web Developer with a desire to always learn more and become better at whatever i am doing. Passionate for building quality products that look and work great.
Frameworks and languages:
javaScript, HTML5, CSS3, Bootstrap3, jQuery
See the Pen Digital Clock by Amandeep (@kaur11) on CodePen.
See the Pen JQuery Calculator by Amandeep (@kaur11) on CodePen.
See the Pen Rock Paper Scissors by Amandeep (@kaur11) on CodePen.
See the Pen Random Meal Generator by Amandeep (@kaur11) on CodePen.
See the Pen Tribute page by Amandeep (@kaur11) on CodePen.
See the Pen Survey Form by Amandeep (@kaur11) on CodePen.
See the Pen Moving circles by Amandeep (@kaur11) on CodePen.
See the Pen Progress Bar by Amandeep (@kaur11) on CodePen.


It is 1911. The Coronation Day of King George V. The Williams, a Welsh coal-mining family is linked by romance and enmity to the Fitzherberts, aristocratic coal-mine owners. Lady Maud Fitzherbert falls in love with Walter von Ulrich, a spy at the German Embassy in London. Their destiny is entangled with that of an ambitious young aide to U.S. President Woodrow Wilson and to two orphaned Russian brothers, whose plans to emigrate to America fall foul of war, conscription and revolution.
On the day King George V was crowned at Westminster Abbey in London, Bill Williams went down the pit in Aberowen, South Wales.


Welcome
,
!
Login
Profile
|
Logout
Voting App
This app allows you to vote on polls (and create them, of course).
My Polls
Polls
Create poll
Enter the poll name:
+
Create!
Amount:
.


Below you'll find a playable version of Lost Ship Adventure that works right in your browser, assuming you have a physical keyboard.
I wrote this game originally in 1980 when I was 14 years old. I really enjoyed the Scott Adams (not the Dilbert guy, a different Scott Adams) text adventures. Like many other kids my age, I decided to write my own game in the same genre, so I began writing Lost Ship Adventure at the end of the school year.
The TRS-80 Users Group of Eastern Massachusetts (TRUGEM) met at my school and I attended every meeting. One evening, a man named Bob Liddil came to the meeting. He had a small software publishing company called "The Programmer's Guild." He was also well-known for writing a column about games under the name "Captain 80." My friends and I showed him the games we were working on. He gave us feedback and said to me that "When you finish that, I can sell it."
Obviously, I was excited by this idea so I spend a couple months of my summer vacation working on it. I sent him the finished program and he did, in fact sell it.
Since then, it has floated around in archived format. There appear to be three versions: one was sold on cassette. It had the "animated" intro screen (which I've restored and updated) and a cassette-based save game routine. The second was the disk version which did not have the banner, but did have a disk-based save. The third version was in a listing in Captain 80's Book of Adventures. All had modifications (such as the animated screen) that I did not code.
This is about what I've done to it in 2021.
When my friend Harry decided to resurrect his game, Arctic Adventure, from the listing in the Captain 80 book, I became interested in doing the same with Lost Ship Adventure. I managed to get most of it working before finding complete copies of the original on the web. The web versions had a problem: they were so hacked that only the most faithful emulators could run them. The web emulator could not.
One of my obsessions was to replicate the split-screen scrolling feature from the Scott Adams games. Adams' games were written in machine code so he could implement whatever screen output he wanted. There was no way to tell BASIC to scroll only part of the screen, so I came up with a hack: a small machine language routine. BASIC had a feature that allowed the code to call a binary routine, so I used that. All I needed was a place to put the short 11-byte piece of code. In order to do that, I created a string with ample space, got the address of the string, and POKE'ed the bytes in. After I'd done that I would save the program and the modified string would be written out.
This didn't work in a listing, nor is it working for some of the emulators. You can't rely on the code being parsed. The Captain 80 book had the solution: it included BASIC code to POKE the machine code in every time the program was run. My first fix to the archived code was to remove the "weird" string from the code, and include the "set it up every time" code. For some reason the person who added this to the listing version had the program run once, alter itself, and then delete the alteration code and tell you to run it again. This was... efficient? ...but I got rid of it.
As it turns out, a couple of weeks before I began playing with this old program, someone published a new review of it. The review was pretty nice, but it pointed out a couple of things.
First, there was a hidden deck on the ship with no logical way to get to it. Of course, getting to this deck was part of the puzzle, but the reviewer pointed out that without *any* other way of getting there, the crew of the ship would have had a hell of a time operating the ship. It was a small item, but it bugged me so I put some stuff in to show a "normal" way to get to the deck, but make it so that you couldn't use that method.
The second criticism was that the story starts out in an interesting world that captures your imagination and then becomes rather dull and ends abruptly. This was an artifact of how the game was created. I began writing the game for my own enjoyment and only expected my school friends to actually play it. For example, the manatee (which also shows up in Dragonquest Adventure) was an in-joke from my high-school friends. The game did not have any kind of overarching plot. The story takes you to an island where things just kind of happen and nothing is really connected. Although the player is expecting it to lead to something, it doesn't. I just wrote until I ran out of ideas.
This isn't the worst approach; JJ Abrams made a hit television show doing the same thing. Stil, I needed a more satisfying ending. I contemplated a few ideas. You discover a lost temple? Too involved. Smoke monster?  Hopefully you'll get far enough to find what I did. I'm pretty happy with it.
Finally, Harry suggested that we somehow link Arctic Adventure and Lost Ship Adventure. We decided that somehow, the SS Deathflower managed to sail to the Arctic where it was wrecked. Now the two games reference this. I think this will go on to become a massive shared universe in the realm of TRS-80 BASIC adventure games.
The original game featured text that would visibly write letter-by letter. Some people liked this. There were two reasons for it.
The first reason is that I packed all of the data about objects into a single string. The format separated the object "name" (e.g. Jewelled Dagger) from the object detailed description in the same string using an asterisk character. While BASIC had a nice MID$ function that could lift these sections out of the packed string, *there was no function to find the index of the delimiter!* For that reason, I had to have `FOR` loops find the delimiter. As I was looping through, I might as well print the characters, right?
The other reason was scrolling. When printing in the scrollable region, I had to "manually" scroll. This mean not printing anything at the end of the line where BASIC would scroll it automatically. Thus, if I had a long piece of text to print, I had to do my own line wrapping, so printing out one character at a time allowed me to manually scroll when I got to close to the end of the line.
In the new version, I go ahead and use MID$ to extract the strings. I also created a subroutine that recursively prints text with line breaks at spaces between words. I think I used recursion in later TRS-80 programs written in assembler, but it was just so hard to do in BASIC because all variable are global.
I hope nobody misses the characters crawling onto the screen.
I fixed a few bugs. For example, EXAMINE-ing objects sometimes has side effects. The original code will perform those side effects even if the item is not around. Later, when you encountered the item, it would have already been transformed. The code is much better at enforcing world logic now, but maybe not perfect.
I improved a lot of the messaging. I think that I was following the terse style of the Scott Adams adventures, but I think it adds a lot to have richer responses.
The save/load game has been removed since it doesn't work in the emulator. I may change this to be an "in-memory" savepoint so you don't have to replay from the start if you die. I've changed enough I'd have to redo the save logic anyway.
Charles Forsythe, September 2021


Cheat Sheet
Lets talk about what prototyping is in JavaScript. At first this may seem like a scary topic, that may be hard to learn. Not to worry. because with this cheat sheet you will become a master on prototyping.
I will start by explaining what is going on in the above example. As you can see I am creating a constructor function called Fish(), which does not except any parameters. Next I use the "this" statement to create objects within this function (for practical reasons I am going to leave the value of these attributes blank). After that I close the function and I do not forget to add a ";"" after the function to signal that it ends. I created a variable called fisherman for this function and I set it equal to an instance of the class Fish(). Now, initiate the two instance of the function as seen on lines 8 and 9, I am now setting the value of fisherman to equal those values. If we were to display fisherman we would see that "Goku", and "Salmon" are but as the properties for each object.
Prototype
In the next example above I added on lines 12 a prototype of the class Fish(), that allows me to add a object and property to Fish(). I specified that I want this new object to have the function weight that accepts one parameter of user information, and returns it. On line 16 I call the object weight in Fish() then I input a parameter in it. Now if I were to display fisherman you would see an object weight has be added to fisherman along with the value of 80 as its property. This make is easier for us to add subclasses into the functions so that we don’t have to do it all inside of the function itself.
Inheritance
Finally, a prototype can help a function inherit from another one. In the example above I have created two functions/class called Fish() and Guppy(). Things to note is that I have set the objects in the functions to equal strings. On line 12 I used the prototype method again, but this time I set it equal to a new instance of Fish(). Now Guppy() will be able to inherit all of the objects and properties of the functions Fish(). When I go to display Guppy.name on line 14 it will now display "Nemo".


Tea website
Hello, I'm NGUYEN Thoai My
I'm a full stack web developper
I'm a Full Stack Developer in France. In addition, I have a great passion for designing user interface with HTML, CSS and Javascript. As a web developer, I want to use my technical competences along with my taste of art for making special things to create the best products.
2018: 3WA ACADEMY - Paris
- Integrator developer training in web application development
- Title RNCP level III (BAC + 2)
2015-2017: University of Western Brittany, France
- Master 2 Financial Engineering
2011-2015: University of Economics in Da Nang, Viet Nam
- Finance and Banking License
My expertise is front-end development and everything related with this side of web (HTML, CSS, JS, coding layouts...) Moreover, I can work as a full-stack web developper (PHP and open source CMS like : Wordpress)
Please check my chart below for more information.
Tea website
Moto website
Images sliding
IT website
Wordpress
Restaurant project
If you have any questions, please don't hesitate to contact me using the form below...


by Richard C. Larson and Amedeo R. Odoni
first published by Prentice-Hall, NJ, © 1981.
Massachusetts Institute of Technology © 1997-99, all rights reserved.
This EPUB is produced from the online version of the book using open source scripts.


Seer Skahi:
Tarkai gave me your instructions.
The Human soul you released can't rest in peace, you must find him again!
Here's your test. The Ketra Orcs, a lower race who betrayed us long ago, and the Varka Silenos are at war. They each have a Divine Stone of Wisdom, but you must earn their absolute trust to get it.
Bring either stone to pass the test.
Which side do you choose?
The Ketra Orcs
The Varka Silenos