32
A Lament over Pharaoh and Egypt
1 In the twelfth year, in the twelfth month, on the first day of the month, the word of the LORD came to me:
2 “Son of man, raise a lamentation over Pharaoh king of Egypt and say to him:
“You consider yourself a lion of the nations,
but you are like a dragon in the seas;
you burst forth in your rivers,
trouble the waters with your feet,
and foul their rivers.
3 Thus says the Lord GOD:
I will throw my net over you
with a host of many peoples,
and they will haul you up in my dragnet.
4 And I will cast you on the ground;
on the open field I will fling you,
and will cause all the birds of the heavens to settle on you,
and I will gorge the beasts of the whole earth with you.
5 I will strew your flesh upon the mountains
and fill the valleys with your carcass.
6 I will drench the land even to the mountains
with your flowing blood,
and the ravines will be full of you.
7 When I blot you out, I will cover the heavens
and make their stars dark;
I will cover the sun with a cloud,
and the moon shall not give its light.
8 All the bright lights of heaven
will I make dark over you,
and put darkness on your land,
declares the Lord GOD.
9 “I will trouble the hearts of many peoples, when I bring your destruction among the nations, into the countries that you have not known.
10 I will make many peoples appalled at you, and the hair of their kings shall bristle with horror because of you, when I brandish my sword before them. They shall tremble every moment, every one for his own life, on the day of your downfall.
11 “For thus says the Lord GOD: The sword of the king of Babylon shall come upon you.
12 I will cause your multitude to fall by the swords of mighty ones, all of them most ruthless of nations.
“They shall bring to ruin the pride of Egypt,
and all its multitude shall perish.
13 I will destroy all its beasts
from beside many waters;
and no foot of man shall trouble them anymore,
nor shall the hoofs of beasts trouble them.
14 Then I will make their waters clear,
and cause their rivers to run like oil,
declares the Lord GOD.
15 When I make the land of Egypt desolate,
and when the land is desolate of all that fills it,
when I strike down all who dwell in it,
then they will know that I am the LORD.
16 This is a lamentation that shall be chanted; the daughters of the nations shall chant it; over Egypt, and over all her multitude, shall they chant it, declares the Lord GOD.”
17 In the twelfth year, in the twelfth month, on the fifteenth day of the month, the word of the LORD came to me:
18 “Son of man, wail over the multitude of Egypt, and send them down, her and the daughters of majestic nations, to the world below, to those who have gone down to the pit:
19 ‘Whom do you surpass in beauty?
Go down and be laid to rest with the uncircumcised.’
20 They shall fall amid those who are slain by the sword. Egypt is delivered to the sword; drag her away, and all her multitudes.
21 The mighty chiefs shall speak of them, with their helpers, out of the midst of Sheol: ‘They have come down, they lie still, the uncircumcised, slain by the sword.’
22 “Assyria is there, and all her company, its graves all around it, all of them slain, fallen by the sword,
23 whose graves are set in the uttermost parts of the pit; and her company is all around her grave, all of them slain, fallen by the sword, who spread terror in the land of the living.
24 “Elam is there, and all her multitude around her grave; all of them slain, fallen by the sword, who went down uncircumcised into the world below, who spread their terror in the land of the living; and they bear their shame with those who go down to the pit.
25 They have made her a bed among the slain with all her multitude, her graves all around it, all of them uncircumcised, slain by the sword; for terror of them was spread in the land of the living, and they bear their shame with those who go down to the pit; they are placed among the slain.
26 “Meshech-Tubal is there, and all her multitude, her graves all around it, all of them uncircumcised, slain by the sword; for they spread their terror in the land of the living.
27 And they do not lie with the mighty, the fallen from among the uncircumcised, who went down to Sheol with their weapons of war, whose swords were laid under their heads, and whose iniquities are upon their bones; for the terror of the mighty men was in the land of the living.
28 But as for you, you shall be broken and lie among the uncircumcised, with those who are slain by the sword.
29 “Edom is there, her kings and all her princes, who for all their might are laid with those who are killed by the sword; they lie with the uncircumcised, with those who go down to the pit.
30 “The princes of the north are there, all of them, and all the Sidonians, who have gone down in shame with the slain, for all the terror that they caused by their might; they lie uncircumcised with those who are slain by the sword, and bear their shame with those who go down to the pit.
31 “When Pharaoh sees them, he will be comforted for all his multitude, Pharaoh and all his army, slain by the sword, declares the Lord GOD.
32 For I spread terror in the land of the living; and he shall be laid to rest among the uncircumcised, with those who are slain by the sword, Pharaoh and all his multitude, declares the Lord GOD.”


Kellys' Heroes (1970) 149m.
A mostly successful hybrid of two genres, the war movie and caper film, which was popular with audiences upon release. Clint Eastwood is topbilled as a former lieutenant (he was busted down when the army needed a scapegoat) fighting for the liberation of France in WWII. He hits upon the idea of robbing a bank behind enemy lines while the country is in turmoil. Eventually Telly Savalas and the rest of his platoon, along with several outsiders, get involved in the plan.
Tone and feel of film on one hand portrays the chaos of war as a giant shoot-em-up adventure playground, but on the other as a brutal and unheroic campaign of destruction. Director Brian G. Hutton and writer Troy Kennedy Martin are intent on blurring the line; to show that in ever-changing battle frontiers there can only be ambiguity. Most ambiguous of all is that these unclear notions of heroism and crime are being packaged as escapist, mainstream entertainment. Eastwood is a complete cipher - he may as well be a carbon copy of the same character he played for Hutton in the previous year's WHERE EAGLES DARE - leaving the more overt roles to players like the cosmically enlightened Donald Sutherland or hustling entrepreneur Don Rickles. Also, it's hard to reconcile the film's title with its events - since when do mercenaries become classed as heroes?  Of course, it could be the film-makers' intention that there are no heroes in war, and that the only valor is getting out alive. Scenes of Kelly (coolly played by Eastwood) and his platoon energetically mowing down German infantrymen become nothing more than just another part of the adventure. The biggest irony - and it is what ‘validates' Eastwood's actions - is that the platoon unknowingly become heroes anyway - or at least as gung-ho general Colt (Carroll O'Conner, in an amusing role) defines the term.
Film's finale is drawn out but comes at the end of much action, humor, and brisk performances by the cast. Fortunately, Hutton elects to keep KELLY'S HEROES light (listen to that theme tune, for example) and doesn't turn it into heavy-handed antiwar bloodletting. For this reason, it becomes one of those unusual things - a war adventure that isn't interested in its own message.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


| English | |
|---|---|
| TSKe | Treasury of Scripture Knowledge (Enhanced) |
| العربية (Arabic) | |
| AVD | ﺎﻠﻜﺗﺎﺑ ﺎﻠﻤﻗﺪﺳ ﺏﺎﻠﻠﻏﺓ ﺎﻠﻋﺮﺒﻳﺓ، ﻑﺎﻧ ﺩﺎﻴﻛ |
| English | |
| UDB-EN | Unlocked Dynamic Bible |
| ULB-EN | Unlocked Literal Bible |
| ελληνικά (Greek) | |
| SBLGNT | SBL Greek New Testament |
| GWH | Wescott & Hort |
| עִבְרִית (Hebrew) | |
| WLC | Westminster Leningrad Codex |
| Bahasa Melayu (Malay) | |
| KSZI | Kitab Suci Zabur Injil |


20 months ago, Mesut Ozil was preparing to win the World Cup Final, yet despite being a champion of the world the Gunners man still divides opinion.
On his day, Vincent Kompany is seen by many as the best centre-back in the world, but now might be the time for Manchester City to say farewell.
Steven Gerrard cried for hours that day because he knew Liverpool had blown his best chance of winning the Premier League title.


Calculate the theoretical size of the defined market in monetary value.
- Start by identifying the key drivers e.g. population, car ownership, age
- Segment based on these factors
- Calculate volume
- Identify Price
- Calculate Market Size
e.g. How many people buy a new car tire each year?
- Population of US 300M
- Car Ownership 80%
- Tires can be classified as: Emergency Replacement or Regular Maintenance
- Emergency Replacement affects 10% of car owners
- Regular Maintenance affects 25% of car owners
- Each tire costs $150
- Volume = 84M
- Market Size = $12.6B


{% include pricing-card.html title="AWS" block=cc1 %}
{% include pricing-card.html title="Google Cloud" block=cc2 %}
{% include pricing-card.html title="Azure" block=cc3 %}
Cloud computing platforms are complex and hard to compare (the list of features and pricing is changing
often).
Based on a specific use case, you will have to pick the best option yourself. Check those articles if
you need help choosing:
Sitepoint, Hacker
News, RightScale.


Sometimes Wikipedia has too much extra formatting. For those times when you really just need plain-text, you can use this tool. Enter the title of the page into the field below to strip it all out.
Download


|
Name
|
Type
|
Description
|
| availablePersistentCapacity | xsd:long |
Persistent Capacity in DIMM currently not allocated
|
| availableVolatileCapacity | xsd:long |
Volatile capacity in DIMM currently not allocated
|
| blockCapacity | xsd:long |
Total block capacity in DIMM (in bytes)
|
| dimmHandle | xsd:int |
Unique device identifier
|
| healthInfo | NvdimmHealthInfo |
Health status of nvdimm.
HealthInfo
|
| persistentCapacity | xsd:long |
Total persistent capacity in DIMM (in bytes)
|
| regionInfo | NvdimmRegionInfo[] |
NVDIMM region information.
List of regions in the NVDIMM. These regions may or maynot
be a part of an interleave set.
|
| representationString | xsd:string |
NVDIMM Representation string which is a sequence of
numbers to uniquely identify the DIMM.
|
| totalCapacity | xsd:long |
Total capacity of NVDIMM in bytes
|
| volatileCapacity | xsd:long |
Total volatile capacity in DIMM (in bytes)
|
|
Properties inherited from DynamicData |
| None |


DOM Optimization Benchmark
with three cases
React (virtual DOM)
Angular 2 (shadow DOM)
Regular DOM (DOM)


| About Dailyrotten |
|
Feedback
If you like this page, hate it, or would like to suggest changes,
<EMAIL_ADDRESS>is listening. This page
is experimental and somewhat different from what we usually offer, so please
do send your feedback.
Adding Stories
If you are a rotten newshound and you would like to suggest a story,
visit our submit page to
send us the URL. Stories that are accepted will have your name credited.
Posting Comments
In order to post comments to stories, you will have to
create an account.
Accounts will generally be validated within 24 hours, and of
course will be disabled if there is abuse.
Viewership
On the first full day this page went live, 100,000 people visited this Rotten
News page. Of course that was the day after the WTC attacks, so that number is
somewhat distorted. Right now this page gets between 50,000 and 75,000 people
every day.
Linking
We encourage everyone to link to this page; if you like it, others probably
will as well.
Other Rotten
Rotten
Gaping Maw
Celebrity Morgue
Mugshots
Rotten Store
Rate My Poo
Rate My Kitten
Rate My Finger
Penny Postcards
Phallic
Boners
Home
Make Dailyrotten your start page
|
|
|
November 04, 2002
Unflattering hot sauce has Tonya Harding all fired up
Canadian Press | Submitted by: Alaska Freegold
"Tonya Hot Sauce features an unflattering caricature of disgraced figure
skater Tonya Harding outside a dumpy trailer, cigarette in mouth, ice skates
in one hand and a hubcap in the other. "Not for the weak-kneed. Guaranteed to assault your taste buds. It's a lead-pipe cinch you'll love it."
"Harding's San Diego attorney William Markham said the spoof defames Harding
and unfairly conjures up memories of what he says are disturbing and
misunderstood events that foiled her dreams of an Olympic championship."
|
|
Read article...
|
|
Teens raped at Children's Day celebration
Independent Online | Submitted by: Alaska Freegold
Two teenagers were raped and another stabbed when about 6,000 children
converged on Zoo Lake, north of Johannesburg, on Saturday, Gauteng police
said. The children were playing music very loud and were under
the influence of alcohol."
|
|
Read article...
|
|
Vomit watch kept on quarterback
News Observer | Submitted by: meatload
"Thank you, ABC, for reminding the world that T.A. McLendon vomits
before every game. If that wasn't enough, sideline reporter Samantha
Ryan expounded on McLendon's ritual and the network displayed a
"Vomit Watch" graphic. It showed that McLendon averages about 100
more yards and two more touchdowns a game when he throws up. The
broadcast booth guys then reported that T.A. hadn't emptied his stomach."
 "Age 16 or 17 is ideal," he is quoted as saying."
|
|
Read article...
|
|
Saving all of Iraq's oil spoils for the USA
Observer | Submitted by: DroelNoel
"Disclosure of the meetings in October in Washington, confirmed by an INC
spokesman, comes as Lord Browne, the head of BP, has warned that British oil
companies have been squeezed out of post-war Iraq even before the first shot
has been fired in any US-led land invasion."
|
|
Read article...
|
|
Security cameras uncovers avian arsonist
Mainichi Daily News | Submitted by: wingnut
"Angry claims by some Kyoto residents about the presence of an evil
arsonist trying to torch one of their favorite landmarks have been
silenced following the discovery that a series of fires had actually
been caused by crows...Sometimes, the candles the crows stole were
lit and when they dropped them on piles of leaves started the fires
that had Fushimi-ku residents on edge with fears that somebody was
trying to burn down the old shrine."
Cool picture of the bird control officer.
|
|
Read article...
|
|
Still feeling subversive?
Guardian | Submitted by: It is-a me-a
Is Levi's using masturbation for marketing?
"They're designed to look amateurish, to leave recipients with the
impression that the advert has a cult following," says Matthew Smith,
director of viral marketing agency the Viral Factory, which masterminds
subviral campaigns for clients ranging from large drinks brands to
government departments... One attachment currently arousing suspicion is a
lewd spoof of the "Rub Yourself" campaign by Levi's. The clip shows
a teenager masturbating onto his jeans and bears a subversive
amateur aura. "I'm suspicious. It's not a spoof that denigrates the brand
or takes the piss, it's more of a homage to it. It could conceivably
be real, but I doubt it."
  Parents are often barred from
entering, though they are encouraged to slip money to guards to prevent
harsher treatment of their children."
|
|
Read article...
|
|
Aussie teens learn how to be thugs
News Corporation | Submitted by: kade
"Authorities have expressed alarm about the club and its techniques,
which include teaching primary school pupils to fight with their fists.
Police Minister Andre Haermeyer told the Herald Sun he found the concept
terrifying... [The operator of the club] said officials had no business
questioning his classes but would not explain how teaching young men
to fight with knives could be considered sensible self-defence."
|
|
Read article...
|
|
Iran revalues price of non-Muslim lives
BBC | Submitted by: bud`
"In Iran, a killer can pay "blood money" to his victim's family to avoid
execution. Under Islamic law, the compensation for a non-Muslim man is one
twelfth that paid for a Muslim. The rate for Muslim women is half that of men."
|
|
Read article...
|
|
Mystery of Area 51
Pravda | Submitted by: anonymous
More craziness from Pravda:
"Let's get something straight from the very beginning: I don't insist at
all that the below mentioned facts are the absolute truth. Many of them
cannot be verified. At the same time, I won't argue with those who say that
a civilization of dormant stones exists on Earth parallel to our civilization;
also, I discuss the question of the existence of life on Mars.
Agreed? If so, letís proceed."
|
|
Read article...
|
|
Long Pig In Britain
Observer | Submitted by: f00f
"Clive Lawrence, Heathrow airport's meat transport director, who was
on the raid, is convinced that human flesh is finding its way into the
UK as part of the bushmeat. He believes that the trade is also linked
to criminal gangs involved in people trafficking and drug smuggling."
|
|
Read article...
|
|
Big boom in crime-scene cleanup companies
US News and World Report | Submitted by: GnoName
Profile of a crime-scene cleanup company, started by two guys who offered
to clean up after a neighbor's shot-gun suicide after they got back from
golfing, They screen potential applicants by telling them about the hot
weather, two week old suicide victim that had liquified all over the car
and garage floor. Billboards in Chicago feature a chalk outline of a corpse,
and the words, "There are some messes no one should have to clean up."
|
|
Read article...
|
|
Gay sheep may explain homosexuality
Wire Services | Submitted by: mayhem
It is common knowledge among biologists that animals often engage in
homosexual behavior, something not generally suspected by the public. In
this case scientists are investigating the brain structures of barnyard
animals known to engage in buggery, confirming differences they
observed in humans.
|
|
Read article...
|
|
Outhouse was site of historic sighting
Anchorage Daily News | Submitted by: Alaska Freegold
Bring your own corncobs: "The site of Dexter Stegemeyer's old outhouse
now sports a plaque designating it as a historic place. It all goes back
to the morning of Oct. 6, 1957, when Stegemeyer was in his outhouse and
all was well with the world. The door was open. As he looked up in
the sky, he witnessed the dawn of a new age."
|
|
Read article...
|
|
Drinking 101
Edmonton Journal | Submitted by: Gorg
"He tells the story of one female student who was so drunk that when she
stumbled into a photocopy room at Corbett Hall she mistook it for a change
room.  Campus Five-Oh was
called the next day when the woman's clothes were discovered. Officers
arriving on scene suspected foul play."
|
|
Read article...
|
|
|
|
|


minListLength) && localValue.length > 0" class="align-top">
Delete this list entry
Please ensure that the list has no duplicates.
{{ addElementText | translate }}


When replacement is active (ON), it means once an event occurs, it can happen again and all other events are
NOT dependent on whether or not it occured.
hover on explanations to display large font.
 With replacement, you will replace
the Queen back into the deck, in the forthcoming events, she could be drawn again, her being replaced means the probabilities will not change on
the second event. Without replacement, she would be removed from future possiblities because she was not placed back into the deck. All further events
are altered by her removed status.
    OFF
Refresh page to reset all data.
Sample Space
Example: There are 4 red marbles, 3 green marbles and 10 blue marbles in a bag. The sample space
would be along the lines of-- 4 red, 3 green, 10 blue, with a total of 17. A dice has 6 numbered sides,
the sample space would be the numbers 1 - 6. A survey where the answer is , yes, no, maybe, 3 outcomes, total of
3. The sample space is the possible outcomes of the trial. Trial would be, roll of the dice, a selection of a marble,
an answer from a survey.


Mobile browsers like Fennec render pages in a virtual "window" (the viewport), usually wider than the screen, so they don't need to squeeze every page layout into a tiny window (which would break many non-mobile-optimized sites). Users can pan and zoom to see different areas of the page. Mobile Safari introduced the "viewport meta tag" to let web developers control the viewport's size and scale. Many other mobile browsers now support this tag, although it is not part of any web standard. Apple's documentation does a good job explaining how web developers can use this tag, but we had to do some detective work to figure out exactly how to implement it in Fennec. For example, Safari's documentation says the content is a "comma-delimited list," but existing browsers and web pages use any mix of commas, semicolons, and spaces as separators. Learn more about viewports in different mobile browsers in A Tale of Two Viewports at quirksmode.org.
The iPhone and many popular Android phones have 3- to 4-inch (7–10 cm) screens with 320—480 pixels (~160 dpi). Firefox for Maemo runs on the Nokia N900, which has the same physical size but 480—800 pixels (~240 dpi). Because of this, the last version of Fennec displayed many pages about one third smaller (in actual, physical size) than iPhone or Android. This caused usability and readability problems on many touch-optimized web sites. Peter-Paul Koch wrote about this problem in A pixel is not a pixel. Fennec 1.1 for Maemo will use 1.5 hardware pixels for each CSS "pixel," following the lead of Android's WebKit-based browser. This means a page with initial-scale=1 will render at close to the same physical size in Fennec for Maemo, Mobile Safari for iPhone, and the Android Browser on both HDPI and MDPI phones. This is consistent with the CSS 2.1 specification, which says
The iPhone and many popular Android phones have 3- to 4-inch (7–10 cm) screens with 320—480 pixels (~160 dpi). Firefox for Maemo runs on the Nokia N900, which has the same physical size but 480—800 pixels (~240 dpi). Because of this, the last version of Fennec displayed many pages about one third smaller (in actual, physical size) than iPhone or Android. This caused usability and readability problems on many touch-optimized web sites. Peter-Paul Koch wrote about this problem in A pixel is not a pixel. Fennec 1.1 for Maemo will use 1.5 hardware pixels for each CSS "pixel," following the lead of Android's WebKit-based browser. This means a page with initial-scale=1 will render at close to the same physical size in Fennec for Maemo, Mobile Safari for iPhone, and the Android Browser on both HDPI and MDPI phones. This is consistent with the CSS 2.1 specification, which says


HAYLEE&GO
Pass
Undo
Resign
Download SGF
Go Board
Illegal move. Try again?
BLACK to play
Result
Hello! Wanna play Go?
Select dead stones:
19x19
13x13
9x9


See: Description
| Interface | Description |
|---|---|
| PubsubOptions |
Properties that can be set when using Google Cloud Pub/Sub with the Apache Beam SDK.
|
| Class | Description |
|---|---|
| PubsubCoderProviderRegistrar |
A
CoderProviderRegistrar for standard types used with PubsubIO . |
| PubsubIO |
Read and Write
PTransform s for Cloud Pub/Sub streams. |
| PubsubIO.PubsubSubscription |
Class representing a Cloud Pub/Sub Subscription.
|
| PubsubIO.PubsubTopic |
Class representing a Cloud Pub/Sub Topic.
|
| PubsubIO.Read<T> |
Implementation of
PubsubIO.read() . |
| PubsubIO.Write<T> |
Implementation of
PubsubIO.write() . |
| PubsubMessage |
Class representing a Pub/Sub message.
|
| PubsubMessagePayloadOnlyCoder |
A coder for PubsubMessage treating the raw bytes being decoded as the message's payload.
|
| PubsubMessageWithAttributesCoder |
A coder for PubsubMessage including attributes.
|
| PubsubUnboundedSink |
A PTransform which streams messages to Pubsub.
|
| PubsubUnboundedSource |
Users should use
PubsubIO.read() instead. |
PubsubIO


|
UQTk: Uncertainty Quantification Toolkit 3.1.3
|
Header file for array read/write utilities. More...
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdlib.h>
#include "Array1D.h"
#include "Array2D.h"
Go to the source code of this file.
Functions | |
| template<typename T > | |
| void | read_datafile (Array2D< T > &data, const char *filename) |
| Read a datafile from filename in a matrix form and store it in the 2d array data of typename T. More... | |
| template<typename T > | |
| void | read_datafileVS (Array2D< T > &data, const char *filename) |
| Read a datafile from filename in a matrix form and store it in the 2d array data if typename T. More... | |
| template<typename T > | |
| void | read_datafileVS (Array1D< Array1D< T > > &data, const char *filename) |
| template<typename T > | |
| void | read_datafileVS (std::vector< T > &data, int &nrows, int &ncols, const char *filename) |
| Read a datafile from filename in a matrix form and store it in a std::vector in column-major storage scheme. More... | |
| template<typename T > | |
| void | read_datafile_1d (Array1D< T > &data, const char *filename) |
| Read a data from filename in a vector form and store it in a 1d array data of typename T. More... | |
| template<typename T > | |
| void | read_datafileVS (Array1D< T > &data, const char *filename) |
| Read a datafile from filename in a vector form and store it in the 1d array data of typename T. More... | |
| template<typename T > | |
| void | write_datafile (const Array2D< T > &data, const char *filename, const char *action) |
| Write/append the contents of a 2d array data of typename T to file filename in a matrix form. More... | |
| template<typename T > | |
| void | write_datafile (const Array2D< T > &data, const char *filename) |
| Write the contents of a 2d array data of typename T to file filename in a matrix form. More... | |
| template<typename T > | |
| void | write_datafile (const std::vector< T > &data, const int &nrows, const int &ncols, const char *storage, const char *filename, const char *action) |
| Write the contents of a vector of typename T to file filename in a matrix form. More... | |
| template<typename T > | |
| void | write_datafile_size (const Array2D< T > &data, const char *filename) |
| Write to file filename the number of rows and number of columns on the first line, followed by the contents of a 2d array data of typename T in a matrix form. More... | |
| template<typename T > | |
| void | write_datafile_1d (const Array1D< T > &data, const char *filename) |
| Write the contents of a 1d array data of typename T to file filename in a vector form. More... | |
Header file for array read/write utilities.
| void read_datafile | ( | Array2D< T > & | data, |
| const char * | filename | ||
| ) |
Read a datafile from filename in a matrix form and store it in the 2d array data of typename T.
| void read_datafile_1d | ( | Array1D< T > & | data, |
| const char * | filename | ||
| ) |
Read a data from filename in a vector form and store it in a 1d array data of typename T.
| void read_datafileVS | ( | Array1D< Array1D< T > > & | data, |
| const char * | filename | ||
| ) |
| void read_datafileVS | ( | Array1D< T > & | data, |
| const char * | filename | ||
| ) |
Read a datafile from filename in a vector form and store it in the 1d array data of typename T.
| void read_datafileVS | ( | Array2D< T > & | data, |
| const char * | filename | ||
| ) |
Read a datafile from filename in a matrix form and store it in the 2d array data if typename T.
| void read_datafileVS | ( | std::vector< T > & | data, |
| int & | nrows, | ||
| int & | ncols, | ||
| const char * | filename | ||
| ) |
Read a datafile from filename in a matrix form and store it in a std::vector in column-major storage scheme.
| void write_datafile | ( | const Array2D< T > & | data, |
| const char * | filename | ||
| ) |
Write the contents of a 2d array data of typename T to file filename in a matrix form.
| void write_datafile | ( | const Array2D< T > & | data, |
| const char * | filename, | ||
| const char * | action | ||
| ) |
Write/append the contents of a 2d array data of typename T to file filename in a matrix form.
| void write_datafile | ( | const std::vector< T > & | data, |
| const int & | nrows, | ||
| const int & | ncols, | ||
| const char * | storage, | ||
| const char * | filename, | ||
| const char * | action | ||
| ) |
Write the contents of a vector of typename T to file filename in a matrix form.
| void write_datafile_1d | ( | const Array1D< T > & | data, |
| const char * | filename | ||
| ) |
Write the contents of a 1d array data of typename T to file filename in a vector form.
| void write_datafile_size | ( | const Array2D< T > & | data, |
| const char * | filename | ||
| ) |
Write to file filename the number of rows and number of columns on the first line, followed by the contents of a 2d array data of typename T in a matrix form.


{% extends "template.html" %} {% block content %}
Have the AI generate a poem
Generate Poem
(This make take a few moments...) {% endblock %}


| Table Header aka th tag ... hmmm | ||
|---|---|---|
| 1st Table Detail in the table row | A second table detail | Oh so much fun |
| only one column on this one | ||
| And a one | And a two |
| Pet Name | Name Pronunciation |
|---|---|
| 1. Odin | Russian - One 'O-den' |
| 2. Zwei | German - Two 'Z-why' |
| 3. Tzsy | Polish - three 'tz-igh' |
| 4.Tessera | Greek - four 't-aye-sara' |
| 5. Koro | Khoisan(Nama) - five 'Core-O' |
| 6. Roku | Japanese - six 'Row-koo' |
| 7. Saba | Swahili - seven |
| 8. |


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 4
Classic tom yum soup with all the hot sour flavours you'd expect. Packed with herbs, spices and vegetables.
Place the stock and water into a large pan over a high heat and bring to the boil.
Add the lemongrass, coriander roots, galangal, tomatoes, lime leaves, lime juice, tamarind water and red chillies. Return to the boil, then reduce the heat and simmer for 15-20 minutes.
Taste the stock and add as much fish sauce and palm sugar as necessary to keep the salty-sour-hot-sweet taste, then remove from the heat.
Transfer 220ml/8fl oz of the stock into a separate pan over a high heat and bring to the boil. Add the chicken and cook for 1-2 minutes, then add the prawns and cook for a further 1-2 minutes, or until completely cooked through.
To serve, pour the soup into two bowls and top up with the hot stock. Garnish with Thai basil, coriander and a wedge of lime.


Your Lonava news is made up of Channels, each of which represents either one Topic, such as "Pictures", or a website, such as "Hacker News".
You will receive all of the news that is posted to any of the channels you Subscribe to. For instance, all the pictures that users post to the "Pictures" channel, as well as every post that is pulled in from "Hacker News".
The Channels you receive are Bolded below. To add a channel, just click on it's name.
To remove a Channel from your account, just click on it, and it will un-bold.
When you are finished with your selections, press the "Modify my Channels" button at the bottom of the page.
{% end %}
|
{{ retrHTMLDivs(uid) }}
|


| I l@ve RuBoard |
This section covers the auto_ptr type. The auto_ptr type is provided by the C++ standard library as a kind of a smart pointer that helps to avoid resource leaks when exceptions are thrown. Note that I wrote "a kind of a smart pointer." There are several useful smart pointer types. This class is smart with respect to only one certain kind of problem. For other kinds of problems, type auto_ptr does not help. So, be careful and read the following subsections.
Functions often operate in the following way[4] :
[4] This motivation of class auto_ptr is based, with permission, partly on Scott Meyers' book More Effective C++. The general technique was originally presented by Bjarne Stroustrup as the "resource allocation is initialization" in his books The C++ Programming Language, 2nd edition and The Design and Evolution of C++. auto_ptr was added to the standard specifically to support this technique.
Acquire some resources.
Perform some operations.
Free the acquired resources.
If the resources acquired on entry are bound to local objects, they get freed automatically on function exit because the destructors of those local objects are called. But if resources are acquired explicitly and are not bound to any object, they must be freed explicitly. Resources are typically managed explicitly when pointers are used.
A typical examples of using pointers in this way is the use of new and delete to create and destroy an object:
void f() { ClassA* ptr = new ClassA; //create an object explicitly ... //perform some operations delete ptr; //clean up (destroy the object explicitly) }
This function is a source of trouble. One obvious problem is that the deletion of the object might be forgotten (especially if you have return statements inside the function). There also is a not-so-obvious danger that an exception might occur. Such an exception would exit the function immediately without calling the delete statement at the end of the function. The result would be a memory leak or, more generally, a resource leak. Avoiding such a resource leak usually requires that a function catches all exceptions. For example:
void f() { ClassA* ptr = new ClassA; //create an object explicitly try { ... //perform some operations } catch (...) { //for any exception delete ptr; //-clean up throw; //-rethrow the exception } delete ptr; //clean up on normal end }
To handle the deletion of this object properly in the event of an exception, the code gets more complicated and redundant. If a second object is handled in this way, or if more than one catch clause is used, the problem gets worse. This is bad programming style and should be avoided because it is complex and error prone.
A kind of smart pointer can help here. The smart pointer can free the data to which it points whenever the pointer itself gets destroyed. Furthermore, because the pointer is a local variable, it gets destroyed automatically when the function is exited regardless of whether the exit is normal or is due to an exception. The class auto_ptr was designed to be such a kind of smart pointer.
An auto_ptr is a pointer that serves as owner of the object to which it refers (if any). As a result, an object gets destroyed automatically when its auto_ptr gets destroyed. A requirement of an auto_ptr is that its object has only one owner.
Here is the previous example rewritten to use an auto_ptr:
//header file for auto_ptr #include <memory> void f() { //create and initialize an auto_ptr std::auto_ptr<ClassA> ptr(new ClassA); ... //perform some operations }
The delete statement and the catch clause are no longer necessary. An auto_ptr has much the same interface as an ordinary pointer; that is, operator * dereferences the object to which it points, whereas operator -> provides access to a member if the object is a class or a structure. However, any pointer arithmetic (such as ++) is not defined (this might be an advantage, because pointer arithmetic is a source of trouble).
Note that class auto_ptr<> does not allow you to initialize an object with an ordinary pointer by using the assignment syntax. Thus, you must initialize the auto_ptr directly by using its value[5] :
[5] There is a minor difference between
X x; Y y(x); //explicit conversion
and
X x; Y y = x; //implicit conversion
The former creates a new object of type Y by using an explicit conversion from type X, whereas the latter creates a new object of type Y by using an implicit conversion.
std::auto_ptr<ClassA> ptr1(new ClassA); //OK std::auto_ptr<ClassA> ptr2 = new ClassA; //ERROR
An auto_ptr provides the semantics of strict ownership. This means that because an auto_ptr deletes the object to which it points, the object should not be "owned" by any other objects. Two or more auto_ptrs must not own the same object at the same time. Unfortunately, it might happen that two auto_ptrs own the same object (for example, if you initialize two auto_ptrs with the same object). Making sure this doesn't happen is up to the programmer.
This leads to the question of how the copy constructor and the assignment operator of auto_ptrs operate. The usual behavior of these operations would be to copy the data of one auto_ptr to the other. However, this behavior would result in the situation, in which two auto_ptrs own the same object. The solution is simple, but it has important consequences: The copy constructor and assignment operator of auto_ptrs "transfer ownership" of the objects to which they refer.
Consider, for example, the following use of the copy constructor:
//initialize an auto_ptr with a new object std::auto_ptr<ClassA> ptr1(new ClassA); //copy the auto_ptr //- transfers ownership from ptr1 to ptr2 std::auto_ptr<ClassA> ptr2(ptr1);
After the first statement, ptr1 owns the object that was created with the new operator. The second statement transfers ownership from ptr1 to ptr2. So after the second statement, ptr2 owns the object created with new, and ptr1 no longer owns the object. The object created by new ClassA gets deleted exactly once — when ptr2 gets destroyed.
The assignment operator behaves similarly:
//initialize an auto_ptr with a new object std::auto_ptr<ClassA> ptr1(new ClassA); std::auto_ptr<ClassA> ptr2; //create another auto_ptr ptr2 = ptr1; //assign the auto_ptr //- transfers ownership from ptr1 to ptr2
Here, the assignment transfers ownership from ptr1 to ptr2. As a result, ptr2 owns the object that was previously owned by ptr1.
If ptr2 owned an object before an assignment, delete is called for that object:
//initialize an auto_ptr with a new object std::auto_ptr<ClassA> ptr1(new ClassA); //initialize another auto_ptr with a new object std::auto_ptr<ClassA> ptr2(new ClassA); ptr2 = ptr1; //assign the auto_ptr //- delete object owned by ptr2 //- transfers ownership from ptr1 to ptr2
Note that a transfer of ownership means that the value is not simply copied. In all cases of ownership transfer, the previous owner (ptr1 in the previous examples) loses its ownership. As a consequence the previous owner has the null pointer as its value after the transfer. This is a significant violation of the general behavior of initializations and assignments in programming languages. Here, the copy constructor modifies the object that is used to initialize the new object, and the assignment operator modifies the right-hand side of the assignment. It is up to the programmer to ensure that an auto_ptr that lost ownership and got the null pointer as value is no longer dereferenced.
To assign a new value to an auto_ptr, this new value must be an auto_ptr. You can't assign an ordinary pointer:
std::auto_ptr<ClassA> ptr; //create an auto_ptr ptr = new ClassA; //ERROR ptr = std::auto_ptr<ClassA>(new ClassA); //OK, delete old object // and own new
The transfer of ownership implies a special use for auto_ptrs; that is, functions can use them to transfer ownership to other functions. This can occur in two different ways:
A function can behave as a sink of data. This happens if an auto_ptr is passed as an argument to the function by value. In this case, the parameter of the called function gets ownership of the auto_ptr. Thus, if the function does not transfer it again, the object gets deleted on function exit:
void sink(std::auto_ptr<ClassA>); //sink() gets ownership
A function can behave as a source of data. When an auto_ptr is returned, ownership of the returned value gets transferred to the calling function. The following example shows this technique:
std::auto_ptr<ClassA> f() { std:: auto_ptr<ClassA> ptr(new ClassA); //ptr owns the new object ... return ptr; //transfer ownership to calling function } void g() { std::auto_ptr<ClassA> p; for (int i=0; i<10; ++i) { p = f(); //p gets ownership of the returned object //(previously returned object of f() gets deleted) ... } } //last-owned object of p gets deleted
Each time f() is called, it creates an object with new and returns the object, along with its ownership, to the caller. The assignment of the return value to p transfers ownership to p. In the second and additional passes through the loop, the assignment to p deletes the object that p owned previously. Leaving g(), and thus destroying p, results in the destruction of the last object owned by p. In any case, no resource leak is possible. Even if an exception is thrown, any auto_ptr that owns data ensures that this data is deleted.
The semantics of auto_ptr always include ownership, so don't use auto_ptrs in a parameter list or as a return value if you don't mean to transfer ownership. Consider, for example, the following naive implementation of a function that prints the object to which an auto_ptr refers. Using it would be a disaster.
//this is a bad example template <class T> void bad_print(std::auto_ptr<T> p) //p gets ownership of passed argument { //does p own an object ? if (p.get() == NULL) { std::cout << "NULL"; } else { std::cout << *p; } } //Oops, exiting deletes the object to which p refers
Whenever an auto_ptr is passed to this implementation of bad_print(), the objects it owns (if any) are deleted. This is because the ownership of the auto_ptr that is passed as an argument is passed to the parameter p, and p deletes the object it owns on function exit. This is probably not the programmer's intention and would result in fatal runtime errors:
std::auto_ptr<int> p(new int); *p = 42; //change value to which p refers bad_print (p); //Oops, deletes the memory to which p refers *p = 18; //RUNTIME ERROR
You might think about passing auto_ptrs by reference instead. However, passing auto_ptrs by reference confuses the concept of ownership. A function that gets an auto_ptr by reference might or might not transfer ownership. Allowing an auto_ptr to pass by reference is very bad design and you should always avoid it.
According to the concept of auto_ptrs, it is possible to transfer ownership into a function by using a constant reference. This is very dangerous because people usually expect that an object won't get modified when you pass it as a constant reference. Fortunately, there was a late design decision that made auto_ptrs less dangerous. By some tricky implementation techniques, transfer of ownership is not possible with constant references. In fact, you can't change the ownership of any constant auto_ptr:
const std::auto_ptr<int> p(new int); *p = 42; //change value to which p refers bad_print(p); //COMPILE-TIME ERROR *p = 18; //OK
This solution makes auto_ptrs safer than they were before. Many interfaces use constant references to get values that they copy internally. In fact, all container classes (see Chapter 6 or Chapter 10 for examples) of the C++ standard library behave this way, which might look like the following:
template <class T> void container::insert (const T& value) { ... X = value; //assign or copy value internally ... }
If such an assignment was possible for auto_ptrs, the assignment would transfer ownership into the container. However, because of the actual design of auto_ptrs, this call results in an error at compile time:
container<std::auto_ptr<int> > c; const std::auto_ptr<int> p(new int); ... c.insert(p); //ERROR ...
All in all, constant auto_ptrs reduce the danger of an unintended transfer of ownership. Whenever an object is passed via an auto_ptr, you can use a constant auto_ptr to signal the end of the chain.
The const does not mean that you can't change the value of the object the auto_ptr owns (if any). You can't change the ownership of a constant auto_ptr; however, you can change the value of the object to which it refers. For example:
std::auto_ptr<int> f() { const std::auto_ptr<int> p(new int); //no ownership transfer possible std::auto_ptr<int> q(new int); //ownership transfer possible *p = 42; //OK, change value to which p refers bad.print(p); //COMPILE-TIME ERROR *p = *q; //OK, change value to which p refers p = q; //COMPILE-TIME ERROR return p; //COMPILE-TIME ERROR }
Whenever the const auto_ptr is passed or returned as an argument, any attempt to assign a new object results in a compile-time error. With respect to the constness, a const auto_ptr behaves like a constant pointer (T* const p) and not like a pointer that refers to a constant (const T* p); although the syntax looks the other way around.
By using auto_ptrs within a class you can also avoid resource leaks. If you use an auto_ptr instead of an ordinary pointer, you no longer need a destructor because the object gets deleted with the deletion of the member. In addition, an auto_ptr helps to avoid resource leaks that are caused by exceptions that are thrown during the initialization of an object. Note that destructors are called only if any construction is completed. So, if an exception occurs inside a constructor, destructors are only called for objects that have been fully constructed. This might result in a resource leak if, for example, the first new was successful but the second was not. For example:
class ClassB { private: ClassA* ptr1; //pointer members ClassA* ptr2; public: //constructor that initializes the pointers //- will cause resource leak if second new throws ClassB (ClassA val1, ClassA val2) : ptr1(new ClassA(val1)), ptr2(new ClassA(val2)) { } //copy constructor //- might cause resource leak if second new throws ClassB (const ClassB& x) : ptr1(new ClassA(*x.ptr1)), ptr2(new ClassA(*x.ptr2)) { } //assignment operator const ClassB& operator= (const ClassB& x) { *ptr1 = *x.ptr1; *ptr2 = *x.ptr2; return *this; } ~ClassB () { delete ptr1; delete ptr2; } ... };
To avoid such a possible resource leak, you can simply use auto_ptrs:
class ClassB { private: const std::auto_ptr<ClassA> ptr1; //auto_ptr members const std::auto_ptr<ClassA> ptr2; public: //constructor that initializes the auto_ptrs //- no resource leak possible ClassB (ClassA val1, ClassA val2) : ptr1 (new ClassA(val1)), ptr2(new ClassA(val2)) { } //copy constructor //- no resource leak possible ClassB (const ClassB& x) : ptr1(new ClassA(*x.ptr1), ptr2(new ClassA(*x.ptr2)) { } //assignment operator const ClassB& operator= (const ClassB& x) { *ptr1 = *x.ptr1; *ptr2 = *x.ptr2; return *this; } //no destructor necessary //(default destructor lets ptr1 and ptr2 delete their objects) ... };
Note, however, that although you can skip the destructor, you still have to program the copy constructor and the assignment operator. By default, both would try to transfer ownership, which is probably not the intention. In addition, and as mentioned on page 42, to avoid an unintended transfer of ownership you should also use constant auto_ptrs here if the auto_ptr should refer to the same object throughout its lifetime.
auto_ptrs satisfy a certain need; namely, to avoid resource leaks when exception handling is used. Unfortunately, the exact behavior of auto_ptrs changed in the past and no other kind of smart pointers are provided in the C++ standard library, so people tend to misuse auto_ptrs. Here are some hints to help you use them correctly:
auto_ptrs cannot share ownership.
An auto_ptr must not refer to an object that is owned by another auto_ptr (or other object). Otherwise, if the first pointer deletes the object, the other pointer suddenly refers to a destroyed object, and any further read or write access may result in disaster.
auto_ptrs are not provided for arrays.
An auto_ptr is not allowed to refer to arrays. This is because an auto_ptr calls delete instead of delete [] for the object it owns. Note that there is no equivalent class in the C++ standard library that has the auto_ptr semantics for arrays. Instead, the library provides several container classes to handle collections of data (see Chapter 5).
auto_ptrs are not "universal smart pointers."
An auto_ptr is not designed to solve other problems for which smart pointers might be useful. In particular, they are not pointers for reference counting. (Pointers for reference counting ensure that an object gets deleted only if the last of several smart pointers that refer to that object gets destroyed.)
auto_ptrs don't meet the requirements for container elements.
An auto_ptr does not meet one of the most fundamental requirements for elements of standard containers. That is, after a copy or an assignment of an auto_ptr, source and sink are not equivalent. In fact, when an auto_ptr is assigned or copied, the source auto_ptr gets modified because it transfers its value rather than copying it. So you should not use an auto_ptr as an element of a standard container. Fortunately, the design of the language and library prevents this misuse from compiling in a standard-conforming environment.
Unfortunately, sometimes the misuse of an auto_ptr works. Regarding this, using nonconstant auto_ptrs is no safer than using ordinary pointers. You might call it luck if the misuse doesn't result in a crash, but in fact you are unlucky because you don't realize that you made a mistake.
See Section 5.10.2, for a discussion and Section 6.8, for an implementation of a smart pointer for reference counting. This pointer is useful when sharing elements in different containers.
The first example shows how auto_ptrs behave regarding the transfer of ownership:
//util/autoptr1.cpp #include <iostream> #include <memory> using namespace std; /* define output operator for auto_ptr * - print object value or NULL */ template <class T> ostream& operator<< (ostream& strm, const auto_ptr<T>& p) { //does p own an object ? if (p.get() == NULL) { strm << "NULL"; //NO: print NULL } else { strm << *p; //YES: print the object } return strm; } int main() { auto_ptr<int> p(new int(42)); auto_ptr<int> q; cout << "after initialization:" << endl; cout << " p: " << p << endl; cout << " q: " << q << endl; q = p; cout << "after assigning auto pointers:" << endl; cout << " p: " << p << endl; cout << " q: " << q << endl; *q += 13; //change value of the object q owns p = q; cout << "after change and reassignment:" << endl; cout << " p: " << p << endl; cout << " q: " << q << endl; }
The output of the program is as follows:
after initialization: p: 42 q: NULL after assigning auto pointers: p: NULL q: 42 after change and reassignment: p: 55 q: NULL
Note that the second parameter of the output operator function is a constant reference. So it uses auto.ptrs without any transfer of ownership.
As mentioned on page 40, bear in mind that you can't initialize an auto_ptr by using the assignment syntax or assign an ordinary pointer:
std::auto_ptr<int> p(new int(42)); //OK std::auto_ptr<int> p = new int(42); //ERROR p = std::auto_ptr<int>(new int(42)); //OK p = new int(42); //ERROR
This is because the constructor to create an auto_ptr from an ordinary pointer is declared as explicit (see Section 2.2.6, for an introduction of explicit).
The following example shows how constant auto_ptrs behave:
//util/autoptr2.cpp #include <iostream> #include <memory> using namespace std; /* define output operator for auto_ptr * - print object value or NULL */ template <class T> ostream& operator<< (ostream& strm, const auto_ptr<T>& p) { //does p own an object ? if (p.get() == NULL) { strm << "NULL"; //NO: print NULL } else { strm << *p; //YES: print the object } return strm; } int main() { const auto_ptr<int> p(new int(42)); const auto_ptr<int> q(new int(0)); const auto_ptr<int> r; cout << "after initialization:" << endl; cout << " p: " << p << endl; cout << " q: " << q << endl; cout << " r: " << r << endl; *q = *p; // *r = *p; //ERROR: undefined behavior *p = -77; cout << "after assigning values:" << endl; cout << " p: " << p << endl; cout << " q: " << q << endl; cout << " r: " << r << endl; // q = p; //ERROR at compile time // r = p; //ERROR at compile time }
Here, the output of the program is as follows:
after initialization: p: 42 q: 0 r: NULL after assigning values: p: -77 q: 42 r: NULL
This example defines an output operator for auto_ptrs. To do this, it passes an auto_ptr as a constant reference. According to the discussion on page 43, you should usually not pass an auto_ptr in any form. This function is an exception to this rule.
Note that the assignment
*r = *p;
is an error. It dereferences an auto_ptr that refers to no object. According to the standard, this results in undefined behavior; for example, a crash. As you can see, you can manipulate the objects to which constant auto_ptrs refer, but you can't change which objects they own. Even if r was nonconstant, the last statement would not be possible because it would change the constant p.
Class auto_ptr is declared in <memory>:
#include <memory>
It provides auto_ptr as a template class for any types in namespace std. The following is the exact declaration of the class auto_ptr:[6]
[6] This is a slightly improved version that fixes some minor problems of the version in the C++ standard (auto_ptr_ref is global now and there is an assignment operator from auto_ptr_ref to auto_ptr; see page 55).
namespace std { //auxiliary type to enable copies and assignments template <class Y> struct auto_ptr_ref {}; template<class T> class auto_ptr { public: //type names for the value typedef T element_type; //constructor explicit auto_ptr(T* ptr = 0) throw(); //copy constructors (with implicit conversion) //- note: nonconstant parameter auto_ptr(auto_ptr&) throw(); template<class U> auto_ptr(auto_ptr<U>&) throw(); //assignments (with implicit conversion) //- note: nonconstant parameter auto_ptr& operator= (auto_ptr&) throw(); template<class U> auto_ptr& operator= (auto_ptr<U>&) throw(); //destructor ~auto_ptr() throw(); //value access T* get() const throw(); T& operator*() const throw(); T* operator->() const throw(); //release ownership T* release() throw(); //reset value void reset(T* ptr = 0) throw(); //special conversions to enable copies and assignments public: auto_ptr(auto_ptr_ref<T>) throw(); auto_ptr& operator= (auto_ptr_ref<T> rhs) throw(); template<class U> operator auto_ptr_ref<U>() throw(); template<class U> operator auto_ptr<U>() throw(); }; }
The individual members are described in detail in the following sections, in which auto_ptr is an abbreviation for auto_ptr<T>. A complete sample implementation of class auto_ptr is located on page 56.
auto_ptr:: element_type
The type of the object that the auto_ptr owns.
auto_ptr::auto_ptr () throw()
The default constructor.
Creates an auto_ptr that does not own an object.
Initializes the value of the auto_ptr with zero.
explicit auto_ptr::auto_ptr (T* ptr) throw()
Creates an auto_ptr that owns and points to the object to which ptr refers.
After the call, *this is the owner of the object to which ptr refers. There must be no other owner.
If ptr is not the null pointer, it must be a value returned by new because the destructor of the auto_ptr calls delete automatically for the object it owns.
It is not correct to pass the return value of a new array that was created by new[]. (For arrays, the STL container classes, which are introduced in Section 5.2, should be used.)
auto_ptr::auto_ptr (auto_ptr& ap) throw()
template<class U> auto_ptr::auto_ptr (auto_ptr<U>& ap) throw()
The copy constructor (for nonconstant values).
Creates an auto_ptr that adopts the ownership of the object ap owned on entry. The ownership of an object to which ap referred on entry (if any) is transferred to *this.
After the operation, ap no longer owns an object. Its value becomes the null pointer. Thus, in contrast to the usual implementation of a copy constructor, the source object gets modified.
Note that this function is overloaded with a member template (see page 11 for an introduction to member templates). This enables automatic type conversions from the type of ap to the type of the created auto_ptr; for example, to convert an auto_ptr to an object of a derived class into an auto_ptr to an object of a base class.
See Section 4.2.2, for a discussion of the transfer of ownership.
auto_ptr& auto_ptr::operator = (auto_ptr& ap) throw()
template<class U> auto_ptr& auto_ptr::operator = (auto_ptr<U>& ap) throw()
The assignment operator (for nonconstant values).
Deletes the object it owns on entry (if any) and adopts the ownership of the object that ap owned on entry. Thus, the ownership of an object to which ap referred on entry (if any) is transferred to *this.
After the operation, ap no longer owns an object. Its value becomes the null pointer. Thus, in contrast to the usual implementation of an assignment operator, the source object gets modified.
The object to which the auto_ptr on the left-hand side of the assignment (*this) refers is deleted by calling delete for it.
Note that this function is overloaded with a member template (see page 11 for an introduction to member templates). This enables automatic type conversions from the type of ap to the type of *this; for example, to convert an auto_ptr to an object of a derived class into an auto_ptr to an object of a base class.
See Section 4.2.2, for a discussion about the transfer of ownership.
auto_ptr::~auto_ptr () throw()
The destructor.
If the auto_ptr owns an object on entry, it calls delete for it.
T* auto_ptr::get () const throw()
Returns the address of the object that the auto_ptr owns (if any).
Returns the null pointer if the auto_ptr does not own an object.
This call does not change the ownership. Thus, on exit the auto_ptr still owns the object that it owned on entry (if any).
T& auto_ptr::operator * () const throw()
The dereferencing operator.
Returns the object that the auto_ptr owns.
If the auto_ptr does not own an object, the call results in undefined behavior (which may result in a crash).
T* auto_ptr::operator-> () const throw()
The operator for member access.
Returns a member of the object that the auto_ptr owns.
If the auto_ptr does not own an object, the call results in undefined behavior (which may result in a crash).
T* auto_ptr::release () throw()
Releases the ownership of the object that the auto_ptr owns.
Returns the address of the object that the auto_ptr owned on entry (if any).
Returns the null pointer if the auto_ptr does not own an object on entry.
void auto_ptr::reset (T* ptr = 0) throw()
Reinitializes the auto_ptr with ptr.
deletes the object that the auto_ptr owns on entry (if any).
After the call, *this is the owner of the object to which ptr refers. There should be no other owner.
If ptr is not the null pointer it should be a value returned by new because the destructor of the auto_ptr automatically calls delete for the object it owns.
Note that it is not correct to pass the return value of a new array that was creates by new []. (For arrays, the STL container classes, which are introduced in Section 5.2, should be used.)
The rest of the class auto.ptr (auxiliary type auto_ptr_ref and functions using it) consists of rather tricky conversions that enable you to use copy and assignment operations for nonconstant auto_ptrs but not for constant auto_ptrs (see page 44 for details). The following is a quick explanation.[7] We have the following two requirements:
[7] Thanks to Bill Gibbons for pointing this out.
It should be possible to pass auto_ptrs to and from functions as rvalues.[8] Because auto_ptr is a class, this must be done using a constructor.
[8] The names rvalue and lvalue come originally from the assignment expression expr1 = expr2, in which the left operand expr1 must be a (modifiable) 1value. However, an 1value is perhaps better considered as representing an object locator value. Thus, it is an expression that designates an object by name or address (pointer or reference). Lvalues need not be modifiable. For example, the name of a constant object is a nonmodifiable 1value. All expressions that are not 1values are rvalues. In particular, temporary objects created explicitly (T()) or as the result of a function call are rvalues.
When an auto_ptr is copied, it is important that the source pointer gives up ownership. This requires that the copy modifies the source auto_ptr.
An ordinary copy constructor can copy an rvalue, but to do so it must declare its parameter as a reference to a const object. To use an ordinary constructor to copy an auto_ptr we would have to declare the data member containing the real pointer mutable so that it could be modified in the copy constructor. But this would allow you to write code that copies auto_ptr objects that were actually declared const, transferring their ownership in contradiction to their constant status.
The alternative is to find a mechanism to enable an rvalue to be converted to an lvalue. A simple operator conversion function to reference type does not work because an operator conversion function is never called to convert an object to its own type (remember that the reference attribute is not part of the type). Thus, the auto_ptr_ref class was introduced to provide this convert-to-lvalue mechanism. The mechanism relies on a slight difference between the overloading and template argument deduction rules. This difference is too subtle to be of use as a general programming tool, but it is sufficient to enable the auto_ptr class to work correctly.
Don't be surprised if your compiler doesn't support the distinction between nonconstant and constant auto_ptrs yet. And be aware that if your compiler does not yet implement this distinction, your auto_ptr interface is more dangerous. In this case, it is rather easy to transfer ownership by accident.
The following code contains a sample implementation of a standard-conforming auto_ptr class[9] :
[9] Thanks to Greg Colvin for this implementation of auto.ptr. Note that it does not conform exactly to the standard. It turned out that the specification in the standard is still not correct regarding the special conversions encountered using auto_ptr_ref. The version presented in this book, hopefully, fixes all the problems. However, at the writing of this book, there was still ongoing discussion.
// util/autoptr.hpp /* class auto_ptr *- improved standard conforming implementation */ namespace std { //auxiliary type to enable copies and assignments (now global) template<class Y> struct auto_ptr_ref { Y* yp; auto_ptr_ref (Y* rhs) : yp(rhs) { } }; template<class T> class auto_ptr { private: T* ap; //refers to the actual owned object (if any) public: typedef T element_type; //constructor explicit auto_ptr (T* ptr = 0) throw() : ap(ptr) { } //copy constructors (with implicit conversion) //- note: nonconstant parameter auto_ptr (auto_ptr& rhs) throw() : ap (rhs. release()) { } template<class Y> auto_ptr (auto_ptr<Y>& rhs) throw() : ap(rhs.release()) { } //assignments (with implicit conversion) //- note: nonconstant parameter auto_ptr& operator= (auto_ptr& rhs) throw() { reset(rhs.release()); return *this; } template<class Y> auto_ptr& operator= (auto_ptr<Y>& rhs) throw() { reset(rhs.release()); return *this; } //destructor ~auto_ptr() throw() { delete ap; } //value access T* get() const throw() { return ap; } T& operator*() const throw() { return *ap; } T* operator->() const throw() { return ap; } //release ownership T* release() throw() { T* tmp(ap); ap = 0; return tmp; } //reset value void reset (T* ptr=0) throw(){ if (ap != ptr) { delete ap; ap = ptr; } } /* special conversions with auxiliary type to enable copies and assignments */ auto_ptr(auto_ptr_ref<T> rhs) throw() : ap(rhs.yp) { } auto_ptr& operator= (auto_ptr_ref<T> rhs) throw() { //new reset(r.yp); return *this; } template<class Y> operator auto_ptr_ref<Y>() throw() { return auto_ptr_ref<Y>(release()); } template<class Y> operator auto_ptr<Y>() throw() { return auto_ptr<Y>(release()); } }; }
| I l@ve RuBoard |


{* Copyright 2011-2013 Here's A Hand Limited Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *} {extends file="page.htm"} {block name="navButtons"} My Group {/block} {block name="content"}


Google Calendar finally lets you move events across calendars
by Joe FedewaIf you’re a frequent user of Google Calendar you’ve probably noticed that the Android app has far fewer features than the desktop version. The desktop is typically viewed as the more “productive” platform, but tons of people rely on their phones for productivity as well. Google is now bringing a long-time desktop feature to Android: moving events between calendars.
Google Calendar for Android has had the ability to copy and duplicate events for a while, but this left the event on multiple calendars. Now, through a server-side update, you can move an event from one calendar to another. To move an event, go into the Edit interface for an event and you can tap the calendar at the top to move it.
Screenshots via Android Police
This is much more convenient for those times when plans change or you mistakenly create an event on the wrong calendar. As mentioned, this is a server-side update, so you can’t simply update the app to get it. You can try force closing and clearing the cache, but that may not work either. We’re glad to see Google continue to work on bringing the mobile version of Google Calendar up to feature parity with the desktop.
Via: Reddit


Wrong name. Must be at least 4 characters. Can't be more than 255 characters.
Wrong email. Invalid email address. Can't be more than 255 characters.


YOU'VE GOT MAIL A movie review by Joe Barlow (c) Copyright 1999
STARRING: Tom Hanks, Meg Ryan, Parker Posey, Greg Kinnear DIRECTOR: Nora Ephron WRITERS: Nora Ephron and Delia Ephron RATED: PG YEAR: 1998 SEEN AT: Starlite Theater, Charlotte NC
RATING: *** (out of a possible *****)
"You've Got Mail," the new Tom Hanks/Meg Ryan extravaganza, strikes a chord somewhere between 'engaging romantic comedy' and 'shameless product placement,' with very little manuvering room on either side. Not since "The Wizard," the late '80s film starring Fred Savage and a bunch of Nintendo games, have I seen a movie so determined to inspire consumer spending (in this case, the America Online service). It's one thing to have a character use a real-world product in a film; it's quite another to have the film grind to a halt while the product is shamelessly promoted by the characters.
It's true that product placement, the process by which vendors pay movie studios big bucks to get their wares up on the screen for a fleeting moment or two, is a neccessary evil, allowing the studios to offset the cost of shooting their latest $100 million blockbuster. If Hollywood can make an additional million dollars by having Bruce Willis wear an Adidas cap in one scene, they're gonna go for it. I can understand this practice (even if I don't like it) in an expensive effects-laden film. I'm less eager to accept it in a romantic comedy. There are no special-effects costs to offset here.
Joe Fox (Hanks) and Kathleen Kelly (Ryan) are both booksellers in modern-day Manhattan. Kelly is the owner of The Shop Around the Corner, an intimate childrens' bookstore founded by her mother, which has been serving the New York community for thirty years. The store is Kelly's passion: she knows every customer by name, and is intimately familiar with each and every book on her shelves. Nothing gives her greater joy than helping a customer find just the right selection.
Joe is the manager of Fox Books, a mammoth Barnes and Noble-type retail outlet which opens down the street from Kathleen's store. Soon the new arrival has usurped all her old business, and The Shop Around the Corner teeters on the brink of bankruptcy. Seeking advice and reassurance, Kelly turns to the same place many people go when they seek comfort: cyberspace.
For quite a while, Kathleen has been corresponding with a friendly guy she met in an AOL (America Online, for the uninitiated) chat room. Over the past several weeks they've become good friends, but they have one unusual stipulation in their friendship: they don't want to share any personal information with each other, including their real names. They address each other only be their handles (Kathleen is SHOPGIRL; he is NY152). Naturally, Kathleen's e-mail buddy turns out to be none other than Joe Fox, her arch-enemy in real-life. The rest of the film chronicles their adventures as the two engage in their inevitable descent into amour.
Forgetting the issue of product placement, the biggest problem I had with this movie is the lack of intimacy on the part of our two protaganists. Surely anyone who is as smitten as both Hanks and Ryan's characters are would not be content to keep their e-mail on such a cold, distant level, never opening up or revealing any personal details about themselves. (In fact, I question whether people truly *can* become infatuated with each other when no personal details are known. Perhaps in real life, when physical beauty can make up for a lack of information, but not in cyberspace. Let me know your thoughts on this subject, dear readers.) The fact that they refuse to share anything personal about each other, even their real names, positively reeks of "forced plot contrivance"; ie, a screenplay that forces its characters to do something that makes little or no sense, simply because there would otherwise be no story.
Director/co-writer Nora Ephron, who also worked with Hanks and Ryan in "Sleepless in Seattle," based her screenplay on the Jimmy Stewart classic, "The Shop Around the Corner" (in which the two characters fall in love via postal letters, rather than e-mail). If her screenplay is a little heavy-handed at times, her direction is quite adequate, and she coaxes strong, confident performances from the entire cast. Particularly fun is Parker Posey ("The House of Yes"), who appears briefly as Hanks' girlfriend. Greg Kinnear also appears as Ryan's sweetheart, and is entertaining with his character's puffed-up self importance.
"You've Got Mail" is neither the best or worst of the current crop of holiday films. Occasionally simple-minded and perhaps fifteen minutes too long, it is nonetheless light-hearted, and admittedly kind of fun (particularly after Hanks discovers Ryan's identity, and chooses to keep her in the dark a while longer). Significantly, this movie is one of the few non-animated films in recent memory to earn a family-friendly PG rating. And I hate to adopt the cliche', but I'm hard-pressed to think of a better 'date' movie.
E-Mail<EMAIL_ADDRESS>Joe Barlow on Film: http://www.ipass.net/~jbarlow/film.htm
If you'd like to receive new film reviews by e-mail, please write to the above address and ask to be put on my mailing list. Or, you can subscribe directly from my web page. Thanks.
-----------== Posted via Deja News, The Discussion Network ==---------- http://www.dejanews.com/ Search, Read, Discuss, or Start Your Own
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object interbase.interclient.CharacterEncodings
public final class CharacterEncodings
An enumeration of IANA character encodings supported by InterClient.
A complete list of IANA encodings may be found at
ftp://ftp.isi.edu/in-notes/iana/assignments/character-sets.
The InterBase name for the IANA character encoding may
be obtained by calling
getInterBaseCharacterSetName()
.
Any of the following character encodings may be specified
on connection using the charSet
connection property.
It is recommended to use one of the static final encoding
variables below
rather than using hardwired encoding names in your application.
The actual encoding names represented by these variables could
change from one release to the next.
See DataSourceProperties.setCharSet
.
for a description of the charSet
connection property.
| Field Summary | |
|---|---|
static java.lang.String |
_8859_1
ISO Latin-1. |
static java.lang.String |
_8859_15
ISO Latin-9. |
static java.lang.String |
_8859_2
ISO Latin-2. |
static java.lang.String |
_KOI8_R
KOI8-R (Kod dla Ohmena i obrabotki Informacii R) MIME name koi8-r . |
static java.lang.String |
Big5
Big 5 Chinese for Taiwan Multi-byte set. |
static java.lang.String |
Cp1250
Windows Eastern Europe/Latin-2. |
static java.lang.String |
Cp1251
Windows Cyrillic. |
static java.lang.String |
Cp1252
Windows Western Europe/Latin-1. |
static java.lang.String |
Cp1253
Windows Greek. |
static java.lang.String |
Cp1254
Windows Turkish. |
static java.lang.String |
Cp437
PC Original. |
static java.lang.String |
Cp850
PC Latin-1. |
static java.lang.String |
Cp852
PC Latin-2. |
static java.lang.String |
Cp857
PC Turkish. |
static java.lang.String |
Cp860
PC Portuguese. |
static java.lang.String |
Cp861
PC Icelandic. |
static java.lang.String |
Cp863
PC Canadian French. |
static java.lang.String |
Cp865
PC Nordic. |
static java.lang.String |
DYNAMIC
|
static java.lang.String |
EUCJIS
Japanese Extended Unix Code (EUC). |
static java.lang.String |
GB2312
Simplified Chinese for People's Republic of China. |
static java.lang.String |
KSC5601
Korean. |
static java.lang.String |
NONE
The default encoding is no encoding at all. |
static java.lang.String |
SJIS
PC and Windows Japanese. |
static java.lang.String |
UnicodeFSS
This code has now been changed to UNICODE_FSS Standard UTF-8. |
static java.lang.String |
UTF16BE
Standard UTF-16BE. |
static java.lang.String |
UTF16LE
Standard UTF-16LE. |
static java.lang.String |
UTF8
Standard UTF-8. |
| Method Summary | |
|---|---|
static java.lang.String |
getInterBaseCharacterSetName(java.lang.String encoding)
Return the InterBase character set name for a supported Java encoding name. |
static java.lang.String[] |
getSupportedEncodings()
Return an array of all Java encodings supported by the driver. |
| Methods inherited from class java.lang.Object |
|---|
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
public static final java.lang.String NONE
If an encoding is not specified using the
charSet
connection property, an attachment
will use the InterBase default NONE
character set.
The NONE
character set attachment specifies
that data is processed as is with no conversions.
The default encoding for your locale is not used.
Because conversions are not performed and no particular
encoding is enforced, all SQL and SQL data is
interpreted byte-wise as the low order byte of a Java Unicode
2-byte character.
Therefore, all SQL and character data should be restricted to
ASCII when connecting to an InterBase
server using the default NONE
character set.
public static final java.lang.String _8859_1
ISO-8859-1
.
The InterBase character set name is ISO8859_1
.
The Java encoding name is 8859_1
.
An 8-bit encoding that supports many latin languages, including Afrikaans, Albanian, Basque, Catalan, Danish, Dutch, English, Faroese, Finnish, French, Galician, German, Icelandic, Irish, Italian, Norwegian, Portuguese, Scottish, Spanish, and Swedish.
public static final java.lang.String _8859_2
ISO-8859-2
.
The InterBase character set name is ISO8859_2
.
The Java encoding name is 8859_2
.
public static final java.lang.String _8859_15
ISO-8859-15
.
The InterBase character set name is ISO8859_15
.
The Java encoding name is 8859_15
.
public static final java.lang.String _KOI8_R
koi8-r
.
The InterBase character set name is KOI8R
.
The Java encoding name is KOI8_R
public static final java.lang.String Big5
Big5
.
The InterBase character set name is BIG_5
.
The Java encoding name is Big5
.
Also known as csBig5
.
public static final java.lang.String Cp1250
windows-1250
.
The InterBase character set name is WIN1250
.
The Java encoding name is Cp1250
;
public static final java.lang.String Cp1251
windows-1251
.
The InterBase character set name is WIN1251
.
The Java encoding name is Cp1251
.
public static final java.lang.String Cp1252
windows-1252
.
The InterBase character set name is WIN1252
.
The Java encoding name is Cp1252
.
public static final java.lang.String Cp1253
windows-1253
.
The InterBase character set name is WIN1253
.
The Java encoding name is Cp1253
.
public static final java.lang.String Cp1254
windows-1254
.
The InterBase character set name is WIN1254
.
The Java encoding name is Cp1254
.
public static final java.lang.String Cp437
IBM437
.
The InterBase character set name is DOS437
.
The Java encoding name is Cp437
.
public static final java.lang.String Cp850
IBM850
.
The InterBase character set name is DOS850
.
The Java encoding name is Cp850
.
public static final java.lang.String Cp852
IBM852
.
The InterBase character set name is DOS852
.
The Java encoding name is Cp852
.
public static final java.lang.String Cp857
IBM857
.
The InterBase character set name is DOS857
.
The Java encoding name is Cp857
.
public static final java.lang.String Cp860
IBM860
.
The InterBase character set name is DOS860
.
The Java encoding name is Cp860
.
public static final java.lang.String Cp861
IBM861
.
The InterBase character set name is DOS861
.
The Java encoding name is Cp861
.
public static final java.lang.String Cp863
IBM863
.
The InterBase character set name is DOS863
.
The Java encoding name is Cp863
public static final java.lang.String Cp865
IBM865
.
The InterBase character set name is DOS865
.
The Java encoding name is Cp865
.
public static final java.lang.String EUCJIS
Extended_UNIX_Code_Packed_Format_for_Japanese
,
and preferred MIME name EUC-JP
.
The InterBase character set name is EUCJ_0208
.
The Java encoding name is EUCJIS
.
A double 7-bit byte set, restricted to A0-FF in both bytes
public static final java.lang.String GB2312
GB2312
.
The InterBase character set name is GB_2312
.
The Java encoding name is GB2312
.
A mixed one byte, two byte set:
20-7E = one byte ASCII A1-FE = two byte PRC Kanji
public static final java.lang.String KSC5601
KS_C_5601-1987
.
The InterBase character set name is also KSC_5601
.
The Java encoding name is KSC5601
.
public static final java.lang.String SJIS
Shift_JIS
.
The InterBase character set name is SJIS_0208
.
The Java encoding name is SJIS
.
Also known as MS_Kanji
.
A Microsoft code that extends csHalfWidthKatakana
to include
kanji by adding a second byte when the value of the first
byte is in the ranges 81-9F or E0-EF.
public static final java.lang.String UnicodeFSS
UTF-8
.
The InterBase character set name is UNICODE_FSS
.
The Java encoding name is UTF8
.
UTF-8 is a 1 to 3 byte universal encoding of 2-byte Unicode in which ASCII has a one byte representation. That is, unlike 2-byte Unicode, ASCII is a subset of UTF-8. This makes UTF-8 a File-Safe encoding, and is therefore known as File System Safe Unicode, or Unicode FSS.
public static final java.lang.String UTF8
UTF-8
.
The InterBase character set name is UTF8
.
The Java encoding name is UTF8
.
UTF-8 is a 1 to 4 byte universal encoding of 2-byte
Unicode in which ASCII has a one byte representation.
The Old UTF8 character set has been replaced by the UNICODE_FSS
use this for File safe unicode or retain backward compatiblity with 7.x or
Older InterBase Servers.
public static final java.lang.String UTF16LE
UTF-16LE
.
The InterBase character set name is UCS-2
or UNICODE_LE
.
The Java encoding name is UnicodeLittleUnmarked
.
public static final java.lang.String UTF16BE
UTF-16BE
.
The InterBase character set name is UCS-2
or UNICODE_BE
.
The Java encoding name is UnicodeBigUnmarked
.
public static final java.lang.String DYNAMIC
| Method Detail |
|---|
public static java.lang.String getInterBaseCharacterSetName(java.lang.String encoding) throws UnsupportedCharacterSetException
java.sql.SQLException
- if the IANA encoding is not supported.
UnsupportedCharacterSetException
public static java.lang.String[] getSupportedEncodings()
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Upload a Plant Photo
Selected Plant
Common Name: {{plant.commonName}}
Cultivar: {{plant.cultivar}}
Uploading new photo will replace this photo.
-
Your file was successfully uploaded for plant {{this.plant.commonName}} {{this.plant.cultivar}} in bed {{this.plant.gardenLocation}}.
File upload failed.
Invalid plant ID


where to buy postcards in Singapore
I joined Postcrossing last month, and I’ve since been keeping a look-out for places that sell postcards, on this tiny island in South-east Asia.
I list a few below. Do you know of others? I hope you and I can add to each other’s knowledge! :slight_smile:
the usual suspects: souvenir shops
- somewhere in Kampong Glam (near Sultan Mosque)
- somewhere in Chinatown
- Raffles Hotel
- National Museum of Singapore
- the shop called Arch, in the shopping mall called Capitol, near City Hall MRT Station
on the art-sy side
- National Gallery of Singapore
- a pop-up bazaar called Invade, in Esplanade Theatres
- Objectifs Centre for Film and Photography
- this photographer, Christine Nagel, has been shooting various sights in Singapore, and sells her own photos as postcards.
unexpected postcards
- the (alcoholic beverages) bar called No. 5 Emerald Hill provides postcards, and mails them out to international addresses, free of charge. You can buy a drink if you feel paiseh. (Information accurate as of late 2019).
this post first appeared at the forum of Postcrossing


fortyseven media
Knock Awesome web design,graphic Design
Home
Don't Hire Us
portfolio
blog
about Us
Contact
That's What We're Talking about!
Awesome.It looks like.
In the mean time
Portfolio
Blog
Homepage
Contact Information


A facility for writing functions that quote their arguments, may sometimes evaluate them in the environment where they were quoted, and may pass them as quoted to other functions.
| Version: | 0.1.2 |
| Published: | 2018-03-26 |
| Author: | Radford Neal |
| Maintainer: | Radford Neal <radfordneal at gmail.com> |
| License: | GPL-2 | GPL-3 |
| NeedsCompilation: | yes |
| Materials: | NEWS |
| CRAN checks: | quotedargs results |
| Reference manual: | quotedargs.pdf |
| Package source: | quotedargs_0.1.2.tar.gz |
| Windows binaries: | r-devel: quotedargs_0.1.2.zip, r-release: quotedargs_0.1.2.zip, r-oldrel: quotedargs_0.1.2.zip |
| OS X binaries: | r-release: quotedargs_0.1.2.tgz, r-oldrel: quotedargs_0.1.2.tgz |
| Old sources: | quotedargs archive |
Please use the canonical form https://CRAN.R-project.org/package=quotedargs to link to this page.


GEIGER (Fries), Phyllis Matilda
Date of death: Wednesday, November 13th, 2019
Date of birth: Tuesday, June 11th, 1929
Age: 90
Location: Kitchener, Ontario
Family
- Spouse: Arlen Geiger
- Children: Cathy (Dale) Kennedy
- Grandchildren: Dawn (Mike) Zuber and Deb (Phil) Panchaud
- Grandchildren: Alanna and Justin Zuber and Samantha and Jessica Panchaud
- Parents: Frederick and Margaret Fries (Goodwin)
- Siblings: Elaine (Bud), Earl (Jackie), Ross (Carla), Doug (Shirley), Gary (Lorraine), Murray (May), Wilbert, Joyce (Ron), Robert and Butch (Shirley)
Visitation: Monday, November 18, 2019, from 2-4 and 7-9 p.m, at the Henry Walser Funeral Home, 507 Frederick Street, Kitchener.
Service: Tuesday, November 19, 2019 at 11 a.m at St. Paul's Lutheran Church, 544 Bridgeport Rd, Kitchener. Interment Parkview Cemetery. Reception to follow.


Click the links below to automatically run the unit tests for the selected version in the frame on the right.


fun addViews(vararg children: View?): Unit
Convenience method for adding multiple children views to the ExpandableFabLayout at once, programmatically. Ensure your children views are of type Overlay, ExpandableFab or FabOption only.


[gecode-users] FloatVar implementation
Filip Konvička
filip.konvicka at logis.cz
Wed Apr 9 13:47:20 CEST 2008
> Yes, that's true and has always been the case (more or less). It used to be
> that one had to have a reserved identifier known by the kernel.
>
> Then, in the end we decided it does not make a difference in practice and
> just include the stubs for variable types into the kernel. Note it is just
> type information about stubs, no information about how variables are
> implemented go into the kernel.
>
> One, of course, could do a dynamic architecture. But's just painful will
> degrade performance and is not very useful: the number of different variable
> types will be pretty limited.
>
> The only thing that is a little odd, is that the specification file from
> which the stubs are generated must be mentioned in the variables.vsl file.
> But cleaning this up we can do if you decide to either contribute your code
> to Gecode directly (;-), so it can just be listed there) or as a separate
> contribution. Please get in touch with us then and we revive the contribs
> configuration again.
I'll have to take a closer look at what kernel actually does with these.
But our implementation, already in its current state, can generate
multiple variable classes. For example, one may choose to use either
boost::numeric::interval<float> or boost::numeric::interval<double> (or
even <long double>) - and the domain implementation code will be reused.
Similarly, I think that many views and constraints can be generic. If
the implementation is designed carefully, it should be quite independent
on whether we use boost.interval or whatever else.
But when we let the users instantiate their own FloatVars by supplying
their FP-arithmetics library of choice, we don't have the variable type
in advance and can't expose it to the kernel at Gecode compile time. Or
can we? Is it sufficient that all the variables have a common base
class? (Even with the restriction that there is just one instantiation
of FloatVar in a program?)
But I'm afraid that I'm guessing too much here, I really need to look
into the kernel...
Cheers,
Filip
More information about the gecode-users
mailing list


{% extends "info_base.html" %} {% load hunt_tags %} {% block includes %} {% endblock includes %} {% block content %}
{% if curr_hunt.is_locked %}
Our next hunt:
{% elif curr_hunt.is_public %}
Our previous hunt:
{% elif curr_hunt.is_day_of_hunt %}
Our current hunt:
{% else %}
Our next hunt:
{% endif %}
{{curr_hunt.hunt_name}}
{{ curr_hunt.display_start_date|date:" m/d/y " }} {{ curr_hunt.display_start_date|time:"h:iA" }} – {{ curr_hunt.display_end_date|date:" m/d/y "}} {{ curr_hunt.display_end_date|time:"h:iA e" }}
Kickoff location is {{ curr_hunt.location }}
{% if team %} View Registration {% else %} Register Now! {% endif %}
{% endif %}We are Puzzle Hunt CMU, a group of puzzle enthusiasts from Carnegie Mellon University. We work together to solve Puzzle Hunts such as the MIT mystery hunt, or any of the many tech company puzzle hunts (examples of such companies include Microsoft, APT and Palantir). We also write and host CMU's very own puzzle hunt once a semester, with the goal of providing a fun-filled experience to as many members of the community as possible.
Very simply put, it's an event where people get together to solve carefully designed puzzles which somehow link together on a larger scale.
A puzzle hunt is typically characterized by its structure. In addition to several normal puzzles, each round has a meta-puzzle, which requires teams to have solved most of the normal puzzles to even unlock, and often requires solvers to incorporate answers from that round's normal puzzles to make sense of.
Our puzzle hunt's structure changes from semester to semester so as to provide new challenges for solvers.
Yeah, check out our current hunt page!
Email the HALP?! LINE ({% contact_email %}) with "Puzzle Hunt" somewhere in the subject line.