Athens shopping hours extended for Christmas period
by GCTTis’ the season for lots of shopping, and buying gifts for loved ones, and to make holiday purchasing easier shops in Athens have extended their opening hours and they will also include a few Sundays of shopping too.
According to the Athens Merchants Association Shop, opening hours will be extended for the Christmas and New Year’s holiday season, starting on December 12 and up until January 2, 2020, when shops traditionally stay closed.
The shop opening hours for the holidays proposed by are as follows:
On weekdays from 09:00 to 21:00, except on Christmas and New Year’s Eve (Tuesday) when the shops will open at 09:00 and close at 18:00.
On Saturday, December 14, the shops in Athens will open at 09.00 and close at 16:00 and on Sunday, December from 15, they will open from 11:00 to 16:00.
On Saturday, December 21, shops will open at 09:00 and close at 18:00 and on Sunday, December 22 they will be open from 11:00 to 18:00.
Shops will remain closed on Christmas and Boxing Day, December 25-26 and will open again on Friday, December 27 from 09:00 until 21:00.
Οn Saturday, December 28 shops will be open from 09:00 to 18:00 and on Sunday, December 29 from 11:00 to 18:00.
On Monday, December 30 the shops will be open from 09:00 to 21:00 and finally on Tuesday, December 31 (New Year’s Eve) from 09:00-18:00.
All the shops will remain closed on January 1 and 2, 2020.


List your space on Storagr


This message describes a person, their contact information, address, occupation, and affiliated organization.
| PREDICATE | DESCRIPTION |
|---|---|
| NAME | The name of the person. |
| ALTERNATE_NAME | An alternate name for the person. |
| DESCRIPTION | A short description of the person. |
| IMAGE | An image of the person. |
| SAME_AS | A link to a page about the person with more information. |
| URL | A URL for the person's website. |
| TELEPHONE | The person's telephone number. |
| The person's email address. | |
| KEY | CryptoKeys associated with the person |
| CONTACT_POINT | A contact point for the person. |
| ADDRESS | The person's postal address as a contact point |
| JOB_TITLE | The person's job title. |
| AFFILIATION | The organization the person is affiliated with. |
| HAS_OCCUPATION | The person's occupation. |
| FAMILY_NAME | The person's family name. |
| GIVEN_NAME | The person's given name. |
| ADDITIONAL_NAME | Any additional names for the person. |
| HONORIFIC_PREFIX | The person's honorific prefix. |
| HONORIFIC_SUFFIX | The person's honorific suffix. |
| PREDICATE | DESCRIPTION |
|---|---|
| CONTACT_TYPE | The type of contact point (e.g., "customer service"). |
| The contact point's email address. | |
| TELEPHONE | The contact point's telephone number. |
| CONTACT_OPTION | A contact option (e.g., "TollFree"). |
| AREA_SERVED | The geographic area served by this contact point. |
| AVAILABLE_LANGUAGE | The language(s) that can be used to contact the contact point. |
| ADDRESS_COUNTRY | The country of the postal address. |
| ADDRESS_REGION | The region of the postal address. |
| ADDRESS_LOCALITY | The locality of the postal address. |
| POSTAL_CODE | The postal code of the postal address. |
| STREET_ADDRESS | The street address of the postal address. |
| POSTOFFICEBOX_NUMBER | The post office box number of the postal address. |
| PREDICATE | DESCRIPTION |
|---|---|
| NAME | The name of the organization. |
| LEGAL_NAME | The legal name of the organization. |
| PREDICATE | DESCRIPTION |
|---|---|
| NAME | The name of the occupation. |
| PREDICATE | DESCRIPTION |
|---|---|
| RECORDS | A list of UPM records. |
| PREDICATE | DESCRIPTION |
|---|---|
| PUBLIC_KEY | The public key. |
| XPUB | The extended public key. |
| PRIVATE_KEY | The private key. |
| XPRIV | The extended private key. |
| KEY_ADDRESS | The key address. |
| ADDRESS_TYPE | The address type. |
| PREDICATE | DESCRIPTION |
|---|---|
| BASE | The base cryptographic key data. |
| TYPE | The type of cryptographic key. |


It is in vain to say human beings ought to be satisfied with tranquillity: they must have action; and they will make it if they cannot find it. Charlotte Bronte
It is in vain to say human beings ought to be satisfied with tranquillity: they must have action; and they will make it if they cannot find it.


本书pdf是 文字版 ，彩图版， 书签良好 。
Structure of Atom–Classical Mechanics
Structure of Atom–Wave Mechanical Approach
Isotopes, Isobars and Isotones
Nuclear Chemistry
Chemical Bonding–Lewis Theory
Chemical Bonding–Orbital Concept
First Law of Thermodynamics
Thermochemistry
Second Law of Thermodynamics
Gaseous State
Liquid State
Solid State
Physical Properties and Chemical Constitution
Solutions
Theory of Dilute Solutions
Osmosis and Osmotic Pressure
Chemical Equilibrium
Distribution Law
Phase Rule
Chemical Kinetics
Catalysis
Colloids
Adsorption
Electrolysis and Electrical Conductance
Theory of Electrolytic Dissociation
Ionic Equilibria–Solubility Product
Acids and Bases
Salt Hydrolysis
Electromotive Force
Photochemistry
SI Units
Mathematical Concepts
Introduction To Computers


Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s.
MoreLorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s.
MoreLorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s.
MoreLorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s.
MoreLorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s. when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged
An unknown printer took a galley of type and scrambled it to make a type specimen book.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s. when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s. when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged
Lorem Ipsum has been the industry's standard dummy text ever since the 1500s
Lorem Ipsum is simply dummy text of the printing and typesetting industry.
demolink.comLorem Ipsum is simply dummy text of the printing and typesetting industry.
demolink.comLorem Ipsum is simply dummy text of the printing and typesetting industry.
demolink.comLorem Ipsum is simply dummy text of the printing and typesetting industry.
demolink.com


Medical Records
Home
(current)
Add
Search
Logout
Record successfully deleted.
×
Welcome
This is a prototype blockchain-based medical record database.
Actions
Add Record
Search Records


Nawaz Sharif stays at family's Avenfield apartment
by https://www.facebook.com/dunyanewsLONDON (Dunya News) – Former prime minister Nawaz Sharif is staying at the Sharif family’s apartment in Avenfield after reaching London and his personal physician Dr. Adnan is accompanying him.
The Pakistan Muslim League-Nawaz (PML-N) supremo’s first appointment with doctors at the Harley Street Clinic has been scheduled for today and his various medical tests – including blood, sugar levels, heart, and kidneys – will be conducted.
It has been learnt that the doctors will decide whether to move Nawaz Sharif to America or not after examining his reports. On the other hand, Dr. Adnan told that the erstwhile premier’s health has improved.
PML-N President and Leader of the Opposition in the National Assembly Shehbaz Sharif talked to media and maintained that Nawaz Sharif reached London due the prayers of the nation. Hassan Nawaz said the foremost priority at present is his father’s health and avoided giving any political statement.
Nawaz Sharif – along with younger brother Shehbaz – had on Tuesday arrived at London’s Heathrow Airport in an air ambulance where he was welcomed by his son Hassan Nawaz, other family members and friends.
Read details: Ex-PM Nawaz Sharif arrives in London


@import uk.gov.hmrc.hmrcfrontend.views.html.components._ @this(hmrcPageHeading : HmrcPageHeading) @() @hmrcPageHeading(PageHeading( text = "Sorry, there is a problem with the service" ))
Try again later.
We saved your answers. They will be available for 30 days.
Contact the Tax Credits Helpline if you need to make changes to your claim or speak to someone about your tax credits.


As a kinesthetic learner with a concrete random thinking style I think DBC's hands-on approach is the right choice for me.
I learn best by doing and I retain information better by trying out what I've learned and putting it to the test. Being able to experiment either by trial and error or by tinkering with the parts of something to see what they do is what I need to grow.
I'm glad DBC had us research our thinking and learning styles right off the bat. Although I knew most of this intuitively, being able to think about it has helped me to better make the provided resources work for me. One example of this is the various tutorial sites I've begun using since starting Phase 0. Although they generally take a long time to complete, I've found I'm learning more from them then most of the other resources that have been provided. Code Academy is an especially a good site which I've spent many hours on completing their lessons.
One of the biggest downsides to this however is the time commitment and the tendency to get lost down rabbit holes, both of which have been my largest struggles so far. I'm sure everyone at DBC is a very eager learner or we wouldn't be here, but finding a balance of how I utilize my time and how much I spend delving into any particular topic is the challenge I'm currently facing. As much as I want to learn everything about everything, timeboxing is definitely crucial to staying on track with the quick pace of material and techniques like Pomodoro I'm hoping will be useful for me in this area. I've also found it helpful each week to review the challenges beforehand and get a sense of what needs to be accomplished so I can assess how to best allocate my time.
In terms of broadening and growing my thinking and learning styles, I think the variety of resources both provided by DBC and out on the web in general are a great way of doing this. To stick to only one way of learning would surely make it more difficult even just trying to find resources that only cater to that one style. Information is everywhere and in a whole variety of forms, but often times the quickest and easiest to access is the best. I can't rely on lengthy tutorials to answer all of my questions so sometimes reading an article or watching a video is the right choice for me.
The more we continue learning in general the more I believe our learning styles will naturally broaden and strengthen at the same time. I think a final challenge in all of this will be retention. Not just learning new material as fast as you can, but also finding ways to maintain that knowledge once you've moved on to the next topic. That's what I'm currently wrestling with as we enter the next stage in Phase 0.


The name must be 4 at 12 digits and can only use Letters, numbers, screenplay and underscore
The last name must be 4 at 12 digits
The email must be 4 at 12 digits and can only use numbers and letters and uppercase
Error: All fields are required
Submitted successfully


i am Aanjaneya Sharma
Beginner
Download ResumeHi!!!! This is Aanjaneya Sharma. I am an engineering student, pursuing my Btech degree from JUIT Solan. I believe my fast learning abilities and commitment to succeed with full honesty, hardwork and dedication.
DOB : 18/11/2000
gender : male
language : hindi, english
phone : +91<PHONE_NUMBER>
email<EMAIL_ADDRESS>country : india
Professional skill
Professional skill
Professional skill
Soft skill
Soft skill
Soft skill
Along with these professional skills i am also familar with MySQL, MS Office, C and Java programming language. Hard-work, honesty and dedication towards work are my another soft skills.
kanha makhan public school
9.4 CGPA
kanha makhan public school
82% in PCM
kanha makhan public school
Jaypee University of Information technology
<EMAIL_ADDRESS>+91<PHONE_NUMBER>
A-89, Ram Nagar, Krishna Nagar, Mathura, India - 281004


| TOTRECS | Total number of records actually contained in the tqr. |
| ACTUALROW | The current value of a 1-based integer cursor on the records of the tqr. This value is -1 when the the cursor is positioned after the last row (EOF position); this value is 0 when the cursor is positioned before the first row (BOF position). |
| ROWSTOSTORE | The requested number of rows when making the query. |
| STARTINGROW | The requested 1-based index of the row from which to start when making the query and populating the tqr with records from db. |
| MORERECS | When this flag is specified, the return value is a string containing a literal true or false, indicating respectively the existence (on the database) of other records more than the requested number. |
| SOURCECOUNT | The return value of the command will be significative only if the tqr has been created from a database source. In this case, the return value indicates the number of records in the database source. |
| ACTUALPAGE | Returns the current page number of the record subset loaded in the tqr. |


HtmlGlobals.Pas (ThtString)
HtmlBuffer.pas (TBuffString)
Depending on the compiler switch UNICODE ThtString is set to an available unicode string type.
If UNICODE is defined it is set to string otherwize to WideString.
Type ThtString is the string type uses in HtmlViewer code.
Type TBuffString is an alias for ThtString and is used in HtmlBuffer.pas.


Files CCore/inc/FileToMem.h CCore/src/FileToMem.cpp
The class FileToMem loads the file to the memory. It is derived from the class ToMemBase.
class FileToMem : public ToMemBase
{
public:
FileToMem() noexcept;
explicit FileToMem(StrLen file_name,ulen max_len=MaxULen);
~FileToMem();
// std move
FileToMem(FileToMem &&obj) noexcept = default ;
FileToMem & operator = (FileToMem &&obj) noexcept = default ;
// swap/move objects
void objSwap(FileToMem &obj);
explicit FileToMem(ToMoveCtor<FileToMem> obj);
};
The first argument of the constructor is the file_name. The second max_len is a length limit.
ToMemBase is std movable. The original object is nullified during the move.
This class is swappable and movable.
PartFileToMem can be used to load parts of a file into a memory buffer. This class loads file parts sequentially.
class PartFileToMem : NoCopy
{
RawFileToRead file;
SimpleArray<uint8> buf;
FilePosType off;
FilePosType file_len;
public:
static constexpr ulen DefaultBufLen = 64_KByte ;
explicit PartFileToMem(StrLen file_name,ulen buf_len=DefaultBufLen);
~PartFileToMem();
FilePosType getFileLen() const { return file_len; }
FilePosType getCurPos() const { return off; }
FilePosType getRestLen() const { return file_len-off; }
bool more() const { return off<file_len; }
PtrLen<const uint8> read();
};
Constructor has two arguments: the file name and the internal buffer length.
getFileLen() returns the file length.
getCurPos() returns the current position.
getRestLen() returns the length of the file part after the current position.
more() returns true, iff there is a room after the current position.
read() reads the next file part from the current position up to the end of the buffer or up to the end of the file. The part is stored in the internal buffer and the constant range of bytes is returned.


CSV Owner
GitHub organisation or user for CSV file
CSV Repository
Repo for CSV file
CSV Path
Path for CSV file
CSV Branch / Commit
Optional branch for CSV file
GitHub user
Your GitHub user-id
GitHub token
GitHub personal token
CSV date column
CSV column containing date
CSV group columns
Comma-separated list of column for group
Read CSV
CSV entries
Number of entries/lines read from CSV
Filters
Columns to filter
Start date (blank=2m ago)
Timeline start
End date (today=blank)
Timeline end
Interval
Interval in days or months (
m
postfix)
Max age
Max age in days for entry to be still valid
Bar Splitting
Split into bars (by CSV field)
Count column
Column to count (empty to count #entries)
Axis category
Entry types for use on axis labels
Title
Chart title
Draw chart
Stacked
Stack bars
CSV delimiter
CSV field delimiter
Some text some message..


JSR-381: A Standard Java API
for Visual Recognition
using Machine Learning
At this point, most of us know Machine Learning (ML) as recognizing patterns in your data, anticipating the likely future behavior of similar data and taking steps to maximize benefits based on those predictions. It represents a massive change in how we solve problems and has long-term effects to the very foundations of computing and to the world in general.
Most ML toolkits require you to learn Python. Python is one of the leading programming languages in data science and ML. But there are 10 million Java developers on the planet that need to build world-class production ML applications that leverage our years of expertise in development and deployment.
This article will cover a deep learning introduction and create a ML model that will be able to classify Star Wars aircrafts in just a few lines of code using Java Specification Request #JSR-381 (“JSR-381”).
JSR-381
The goal of JSR-381 is to develop a standardized Java-friendly API which can be used to solve small and complex tasks by applying ML specifically to visual recognition use cases.
Each ML engine (eg, TensorFlow, Deep Netts) has its own way of accepting input. It is a relatively large effort to standardize this type of input and therefore won’t be covered in this JSR. For now, the following features will be included into JSR-381 to simplify training and using the ML model:
- Binary classification to classify input which has the outcome true/false, yes/no, dark/bright, etc;
- Image classification to classify an image as input and the outcome of two or more trained labels, depending on the model;
- Object detection to detect and classify one or more fragments in the image as input with as outcome, one or more trained labels;
- Training tools to build the ML model for binary classification, image classification and object detection.
At the same time as the development of the API, the first implementation of the API will be developed as well. This is the so called “Reference Implementation” (RI) which will meet all the requirements of the API as prescribed by the Java Community Process (JCP). The RI of JSR-381 uses Deep Netts, an open source deep learning engine written in pure Java. Amazon has its own implementation of JSR-381 which will support TensorFlow, Apache MXNets and other upcoming engines using their abstraction API called Deep Java Library (DJL).
Supported algorithms
Not every developer is a mathematician. Neither am I. With JSR-381 you won’t have to understand the underlying math of these algorithms because it’s developed to allow you to use common Java design patterns instead of generated wrappers for native libraries. JSR-381 will only support neural networks by default and expose a high level API to use. Each implementation of JSR-381 will have to support neural networks but may also expose other algorithms and implementation specific algorithms to solve complex problems, which are better solved by algorithms other than neural networks. This way JSR-381 can be used by beginners and advanced ML Java developers alike.
Quick dive into understanding classification and deep learning
Classification is commonly used to determine whether the given input is answer A, B or even C. For each classification model, it needs a given set of labels and a prepared dataset. A part of preparing the dataset labelling the data.  This way the ML model will be able to learn and tell whether a newly given picture has to be classified as a cat or a dog. As previously explained, binary classification will only contain two labels which will be complete opposites of each other. The scenario of the dog and the cat is also binary classification. But it might also need to classify all bird pictures as birds. Afterwards the dataset and labels will be expanded with new data and the model will be retrained to classify cats, dogs and birds. This is called multiclass classification.
MNIST is the most known multiclass classification ML model. MNIST is able to classify numeric characters from 0 to 9. Every ML engine has an example using MNIST because the dataset is free to download. The MNIST dataset has already been prepared to be trained with high accuracy.
Deep learning
Deep learning is a specific ML technique based on using multiple neural network layers. There are different algorithms but the one that’s often applied for image classification is called convolutional neural network. This type of algorithm has adaptive image filtering through network layers and then performs the classification on the trained model and results into labeled output like you would with any classifier.
Use the Force to Learn about ML
Now that we have a basic understanding of the use of classification and deep learning, let's create a critically important application example in which it identifies two aircrafts from the Star Wars franchise. In this article we’re building a binary classifier to solve this problem. The reason why we're not using a multi-class classifier is because we’re only identifying the input image as the Millennium Falcon or the Tie Fighter. For those who are not familiar these names, shame on you! But these are the most iconic aircrafts that I’m talking about:
Tie Fighter
Millennium Falcon
Dataset preparation
As mentioned, each ML model will start by gathering the dataset. This can be a very time consuming process, therefore we will skip this part for now. We’ll use a prepared dataset containing only 60~ images for each label. Normally you’d want to create a dataset that contains many more images but it will work just fine for our use case. The general rule of preparing the dataset is to keep the amount of images equal to each label otherwise you might create a biased ML model. Our dataset contains a labels file, a training file which maps the images to a label and a folder of images.
Defining the neural network architecture
The image classifier demands a network architecture to train the ML model. Picking the right architecture is important but depending on the needs of the project, you might want to pick a smaller architecture to reduce training time and still train a model that will have a good accuracy. Because we have a really small dataset and picking the largest architecture won’t make any difference in the resulting accuracy, we will use the architecture that is used in the MNIST example.
Training the ImageClassifier
Using JSR-381 exposes the ImageClassifier using neural networks. We start by first creating a new builder instance:
ImageClassifier<?> classifier = NeuralNetImageClassifier.builder()
...
.build();
It’s important to let the builder know which class type you wish to perform classification on. Because not all implementations will be able to classify that input class with the exception of the BufferedImage class. That one is supported by all implementations so we can safely use it:
ImageClassifier<BufferedImage> classifier = NeuralNetImageClassifier.builder()
.inputClass(BufferedImage.class)
...
.build();
You can see the difference between the snippets where the generic type of the resulting ImageClassifier is changed. There’s no need to cast the resulting ImageClassifier yourself because that’s been taken care of safely within the API.
The dataset configuration is coming next. All images within the dataset should be normalized. This means that all images should have the same width and height. Depending on the implementation, the implementation might normalize the images as a preparation step but will definitely slow the process of training the actual ML as it’s a part of preparing the dataset. Increasing the size will allow better accuracy most of the time but it also requires more computing time so training the model will take longer.
The MNIST example has an image width and height of 28 pixels. In this use case with these few images in our dataset, setting the width and height to 128 pixels was showing better results. Bigger resolutions will contain more content and information that might improve the ML model while training the neural network.
ImageClassifier<BufferedImage> classifier = NeuralNetImageClassifier.builder()
.inputClass(BufferedImage.class)
.imageWidth(128)
.imageHeight(128)
...
.build();
Then we specify the location of two files. One for all the labels that you want to use and one file that contains the mapping of all images with the corresponding label.
ImageClassifier<BufferedImage> classifier = NeuralNetImageClassifier.builder()
.inputClass(BufferedImage.class)
.imageWidth(128)
.imageHeight(128)
.labelsFile(new File("..."))
.trainingFile(new File("..."))
...
.build();
The architecture of the neural network is defined in a JSON file and copied from the MNIST example. Because we don’t want to change the architecture, there are two layers which have to be changed. The input layer has to be set the same as the image width and height of 128 pixels and the output layer should return two labels because we’re only classifying the Millennium Falcon and the Tie Fighter. We pass the architecture file to the builder.
...
..networkArchitecture(new File("...json"))
...
Next we export our model to a file and set that parameter as well. It’s completely optional but training the model may take some time and you don’t want to retrain the model each time you wish to use it.
...
.exportModel(Paths.get("starwars.dnet"))
...
Finally, we have to set the training parameters. These are parameters that have to be experimented with to “guess” which settings suits the model in order to get the best results in a decent amount of training time. Training this model only took a couple of minutes. This is relatively fast and training it with more iterations didn’t show any significant difference in the accuracy.
ImageClassifier<BufferedImage> classifier = NeuralNetImageClassifier.builder()
.inputClass(BufferedImage.class)
.imageWidth(128)
.imageHeight(128)
.labelsFile(new File("...txt"))
.trainingFile(new File("...txt"))
.networkArchitecture(new File("...json"))
.exportModel(Paths.get("starwars.dnet"))
.maxEpochs(1000)
.maxError(0.3f)
.learningRate(0.01f)
.build();
The maxEpochs setting sets the maximum amount of iterations before stopping the model’s training process. The maxError setting is used to stop the training once it hits the error rate of the training process. The learningRate setting is how fast you wish to train the model. With a lower rate it takes more time to train the model but that doesn’t have to improve the accuracy. Meaning it will have more iterations/epochs and takes more time to hit the maximum error rate.
Put the trained model to use
Finally, we’ve trained the model! Now I’d like to classify an image that was not used in the dataset and see if my model can identify it. I randomly took images of the Tie Fighter and the Millennium Falcon from Google search and ran it into the model. The ImageClassifier accepts the generic type, InputStream or File as input:
BufferedImage tieFighter = ...;
Map<String, Float> results = imageClassifier.classify(tieFighter);
System.out.println(results)
The console would output similarly to:
{ "tie_fighter": 0.78f, "millennium_falcon": 0.22f }
The accuracy is approximately 80 percent which shows a decent distinction between a Tie Fighter and a Millennium Falcon. I wouldn’t want to rely on 80 percent accuracy during an intergalactic dogfight, but it's good enough for our learning purposes. In a future version of the API, additional statistical evaluation should be performed after training the model to determine the accuracy.
Summarizing what's learned and what's upcoming
The article described the goal of JSR-381, taught a basic understanding of image classification and deep learning and allowed you to create a ML model step by step by using only JSR-381. In case you want to run only the code, you checkout the GitHub repository at https://github.com/JavaVisRec/jsr381-starwars
What’s to be expected in the future
Many features beyond the current set are in the planning stages for JSR-381. The following major features are very likely to be added in the upcoming versions.
- Export models as ONNX (Open Neural Network Exchange);
- Model evaluation;
- Object detection;
- Transfer learning.
Become a part of the VisRec community
The VisRec working group is always looking for anyone to help, test and develop features for the next versions of the API. Feedback is also always welcome. Visit https://groups.io/g/visrec
Kevin Berendsen
Kevin Berendsen is software engineer at OpenValue, maintainer of JSR-381 and passionate about bringing Java and ML together.


Changelog:
- 3.0-beta-2:
- Improved Activator Gesture Feedback
- Screen Wake Feedback
- Home Button Feedback
- Advanced Shutdown Warning
- Icon Tap Feedback
- Feedback Whenever You Touch The Screen
- 3.0-beta-1:
- Taptic Engine Support
- Using Text selection Feedback
- Open Spotlight Search Feedback
- Call/FaceTime Status Changed
- Authenticated with Touch/FaceID
- Sleep Button Feedback
- Custom Activator Gesture


Restive Kashmir marks 100 days since India stripped autonomy
SRINAGAR, Nov 12 — Kashmir today marked 100 days since India stripped the restive Himalayan valley of its autonomy and imposed a strict communications blackout, with local journalists protesting the internet blackout.
Tensions have been high since August 5 when the national government moved to bring the region under direct rule, cut telecommunications and detained thousands to quell any unrest.
Shops and businesses have remained shut to protest against the controversial decision, and children have not been going to school.
Dozens of journalists held a silent demonstration against the internet ban, holding their laptops with open with blank screens or held placards with the words “100 days no internet” and “stop humiliating Kashmir journalists”.
“The authorities have treated journalists too as potential trouble-makers and choked journalism in the process,” a freelance journalist reported AFP.
“Internet is so fundamental to journalism in this day and age. The authorities have choked our practices instead of enabling free press here,” said another journalist, Naseer Ganai.
Authorities have justified the ban as necessary to stop militants from neighbouring Pakistan from using the internet to fan radicalisation in the territory.
They instead set up an office with 10 internet-enabled stations for around 200 working journalists, who queue up to use the computers for 15 minutes each.
The protest came as reports said three militants died in two separate gunfights with government forces this week.
Kashmir has been split between India and Pakistan since 1947 and has sparked two wars and numerous flare-ups between the two nuclear-armed foes, most recently in February when they conducted tit-for-tat air strikes.
Pakistan today on display a statue of an Indian pilot whose plane was shot down over Kashmir during the February skirmishes. — AFP


CAAT.Actor
Clip
Clipping is by default disabled on CAAT. Enabling it results in slowe performance, so it must be treated carefully. It can be enabled globally by setting CAAT.Actor.prototype.clip= true.
Optionally, the developer can enable/disable clipping for individual actors by settings Actor's clip attribute to true or false or by calling the method setClip(bool).
The clip area will the actor's bounding box with all its transformations applied.
Clip will work only on canvas and DOM/CSS renderers. I've still to implement the GL scissors for the webGL renderer.
Example
This example allows dragging of its content and subcontent. Use shift+alt+control to modify default drag behavior. One of the Scene Actors will have clipping enabled. You'll see that in one instance you're able to drag the inner green Actor outside the Magenta one area. But after dropping it outside its parent area, you won't be able to gain mouse control over the inner Actor again. This is because of the way CAAT routes events to its Actors. In order to send an event to an Actor, the Actor must be contained into its parent area. Period.
var _director_5= new CAAT.Director().initialize( 600, 200, document.getElementById('_c5') ); var _scene_5= _director_5.createScene().setFillStyle('#c0c0c0'); for(var i=0; i<2; i++ ) { // rectangle shaped actors of 80x80 pixels. var s = 80; // containers can contain other actors or containers. var _c5_container = new CAAT.ActorContainer(). setBounds(i*400+10, 20, s, s). setRotation( Math.PI*2*Math.random() ). setFillStyle('#ff3fff'). enableDrag(). setClip( i==0 ); // set container paint routine to draw an arrow _c5_container.paint= function(director, time) { var crx= director.ctx; // fill actor crx.fillStyle= this.fillStyle; crx.fillRect(0,0,this.width,this.height ); // outline it. crx.strokeStyle= 'black'; crx.strokeRect(0,0,this.width,this.height ); // draw a white arrow. just to point where position 0,0 is. crx.strokeStyle='white'; crx.beginPath(); crx.moveTo(5,10); crx.lineTo(20,10); crx.lineTo(15,5); crx.moveTo(20,10); crx.lineTo(15,15); crx.lineWidth=2; crx.lineJoin='round'; crx.lineCap='round'; crx.stroke(); }; // add actor to scene. _scene_5.addChild(_c5_container); // create a container. var _c5_container_child= new CAAT.ActorContainer(). setBounds(s/2,s/2,s/4,s/4). setRotation( Math.PI*2*Math.random() ). setFillStyle('#00ff00'). enableDrag(); // set a custom paint function for children inside containers. _c5_container_child.paint= function(director,time) { // call default container paint method. CAAT.ActorContainer.superclass.paint.call(this,director,time); var ctx= director.ctx; // fill a white circle of 10x10 pixels at position 2,2 // just to show where 0,0 is positioned on screen. ctx.fillStyle='white'; ctx.beginPath(); ctx.arc(7,7,5,0,2*Math.PI,false); ctx.fill(); } // add this container as a child of the previous created container. _c5_container.addChild(_c5_container_child); } CAAT.loop(20);


Sunni Wakf Board Distances Itself From AIMPLB’s Decision To File Review Petition Against SC Verdict In Ayodhya Case
by IANSThe Sunni Waqf Board has said that it is distancing itself from the decision of the All India Muslim Personal Law Board (AIMPLB) on the filing of a review petition against the Supreme Court verdict on the Ayodhya title suit.
"We will not file any review petition," said Zufar Faruqi, chairman of the board, while talking to a news channel.
He said: "We had said on 9 November when the verdict was announced that we will accept the court decision. We are not going with the AIMPLB on this issue."
Replying to a question, Faruqi said: "We cannot say why the AIMPLB is going for a review petition. We had always said that we would accept the decision of the Supreme Court and we are following our stand."
Another Babri litigant Iqbal Ansari has also said that he would not file or support a review petition.
The All India Muslim Personal Law Board had said on Sunday (17 November) that the Supreme Court verdict was self-contradictory and they would file a review petition.
The three parties who have given their consent for the legal drill are Haji Mehboob, Maulana Hizbullah and the two sons of late Haji Abdul Ahad (one of the first Muslim litigants), Haji Asad Ahmad and Hafiz Rizwan.
While the Jamiat Ulama-i-Hind, another party to the dispute, said it would separately file a review plea.
(This story has been published from a wire agency feed without modifications to the text. Only the headline has been changed.)


Note: tested on Chrome 61.
If you see a message below (generated by Handlebars), the demo worked. Open the Developer Tools to see the network requests being made—there's about 35 to go, so it's slow on the first load.


--- title: Contact heading: Get in touch today description: We'd love to help you with your software. ---


GameObject.ArtificialIntelligence
Class LowIntelligence
java.lang.Object
GameObject.ArtificialIntelligence.ArtificialIntelligence
GameObject.ArtificialIntelligence.LowIntelligence
- All Implemented Interfaces:
- java.io.Serializable
public class LowIntelligence
- extends ArtificialIntelligence
- implements java.io.Serializable
Class used to establish the logic implemented by low intelligence enemies. Low intelligence enemies move in one
direction until they hit an obstacle, which reverses their direction of movement. Low intelligence enemies
do not have any logic defined for chasing the player through the grid.
- See Also:
- Serialized Form
|
Method Summary |
void |
chasePlayer(int playerPosX,
int playerPosY,
int distanceFromEnemyToPlayer,
Enemy enemy)
Abstract method implemented by the three intelligence levels present in the game. |
void |
move(Enemy enemy)
The movement of low intelligence enemies consists of the standard logic inherited
from the Artificial Intelligence class. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
LowIntelligence
public LowIntelligence()
move
public void move(Enemy enemy)
- The movement of low intelligence enemies consists of the standard logic inherited
from the Artificial Intelligence class.
- Specified by:
move
in class ArtificialIntelligence
- Parameters:
enemy
- Enemy object to be moved on the grid.
chasePlayer
public void chasePlayer(int playerPosX,
int playerPosY,
int distanceFromEnemyToPlayer,
Enemy enemy)
- Description copied from class:
ArtificialIntelligence
- Abstract method implemented by the three intelligence levels present in the game.
- Specified by:
chasePlayer
in class ArtificialIntelligence
- Parameters:
playerPosX
- x coordinate of the player object on the grid.playerPosY
- y coordinate of the player object on the grid.distanceFromEnemyToPlayer
- Distance between the center of the player object
and the center of the enemy object.enemy
- Enemy object that will start chasing the player.


sqlsrv_fetch_array
(No version information available, might only be in Git)
sqlsrv_fetch_array — Returns a row as an array
说明
array sqlsrv_fetch_array ( resource $stmt [, int $fetchType [, int $row [, int
$offset ]]] )
Returns the next available row of data as an associative array, a numeric
array, or both (the default).
参数
stmt
A statement resource returned by sqlsrv_query or sqlsrv_prepare.
fetchType
A predefined constant specifying the type of array to return. Possible
values are SQLSRV_FETCH_ASSOC, SQLSRV_FETCH_NUMERIC, and SQLSRV_FETCH_BOTH
(the default).
A fetch type of SQLSRV_FETCH_ASSOC should not be used when consuming a
result set with multiple columns of the same name.
row
Specifies the row to access in a result set that uses a scrollable cursor.
Possible values are SQLSRV_SCROLL_NEXT, SQLSRV_SCROLL_PRIOR,
SQLSRV_SCROLL_FIRST, SQLSRV_SCROLL_LAST, SQLSRV_SCROLL_ABSOLUTE and,
SQLSRV_SCROLL_RELATIVE (the default). When this parameter is specified, the
fetchType must be explicitly defined.
offset
Specifies the row to be accessed if the row parameter is set to
SQLSRV_SCROLL_ABSOLUTE or SQLSRV_SCROLL_RELATIVE. Note that the first row
in a result set has index 0.
返回值
Returns an array on success, NULL if there are no more rows to return, and
FALSE if an error occurs.
范例
Example #1 Retrieving an associative array.
"dbName", "UID"=>"username", "PWD"=>
"password");
$conn = sqlsrv_connect( $serverName, $connectionInfo );
if( $conn === false ) {
die( print_r( sqlsrv_errors(), true));
}
$sql = "SELECT FirstName, LastName FROM SomeTable";
$stmt = sqlsrv_query( $conn, $sql );
if( $stmt === false) {
die( print_r( sqlsrv_errors(), true) );
}
while( $row = sqlsrv_fetch_array( $stmt, SQLSRV_FETCH_ASSOC) ) {
echo $row['LastName'].", ".$row['FirstName']."
";
}
sqlsrv_free_stmt( $stmt);
?>
Example #2 Retrieving a numeric array.
"dbName", "UID"=>"username", "PWD"=>
"password");
$conn = sqlsrv_connect( $serverName, $connectionInfo );
if( $conn === false ) {
die( print_r( sqlsrv_errors(), true));
}
$sql = "SELECT FirstName, LastName FROM SomeTable";
$stmt = sqlsrv_query( $conn, $sql );
if( $stmt === false) {
die( print_r( sqlsrv_errors(), true) );
}
while( $row = sqlsrv_fetch_array( $stmt, SQLSRV_FETCH_NUMERIC) ) {
echo $row[0].", ".$row[1]."
";
}
sqlsrv_free_stmt( $stmt);
?>
注释
Not specifying the fetchType or explicity using the SQLSRV_FETCH_TYPE constant
in the examples above will return an array that has both associative and
numeric keys.
If more than one column is returned with the same name, the last column will
take precedence. To avoid field name collisions, use aliases.
If a column with no name is returned, the associative key for the array element
will be an empty string ("").
参见
• sqlsrv_connect() - Opens a connection to a Microsoft SQL Server database
• sqlsrv_query() - Prepares and executes a query.
• sqlsrv_errors() - Returns error and warning information about the last
SQLSRV operation performed
• sqlsrv_fetch() - Makes the next row in a result set available for reading
User Contributed Notes 2 notes
===============================================================================
Note that while the docs say to avoid SQLSRV_FETCH_ASSOC when dealing with
result sets where multiple fields have the same name, there are cases when this
is perfectly valid to do.
Consider the following query:
SELECT * FROM a INNER JOIN b ON a.id = b.id
For any row, if you fetch NUMERIC you'll get a field for both a.id and b.id,
which probably isn't very useful.
If you fetch ASSOC, you'll get one field for "id", and given that it's always
the same in both tables (because your query insists it is so), you're not at
risk of losing anything.
If you're generating output based on an unknown number of fields, the ASSOC
behavior might be preferred.
===============================================================================
Note that using a foreach loop on an array built by sqlsrv_fetch_array without
specifying either SQLSRV_FETCH_NUMERIC or SQLSRV_FETCH_ASSOC will go through
both the associative and numeric keys in the array. This can be a problem if
you're trying to write to a CSV file for example; you'll end up with double
data.


{%extends "registration/base.html"%} {% load bootstrap3 %} {% block content %}
Enter your details to login.
{% if form.errors %}Password or Username is incorrect
{% endif %}By clicking login, you agree to our Terms & Conditions!
Already have an account? Sign in here


Collecting Static Files¶
Contents
In the Django documentation, static files are files linked into your html documents like .css
and .js
as well as images files like .png
and .jpg
. These are served directly by your web server (Apache, Nginx, etc.) rather than by Django because they don’t require any processing. Their contents are just copied to the browser. Serving static files is what web servers were written for.
Django-Mako-Plus works with static files the same basic way that traditional Django does – with one difference: the folder structure is different in DMP. DMP-enabled apps contain the following directories:
app/
media/
scripts/
styles/
templates/
views/
At deployment, collect static files out of these directories with the following command:
python3 manage.py dmp_collectstatic
python manage.py dmp_collectstatic
If your project contains both DMP and regular Django apps, you can collect static files with both commands:
python3 manage.py collectstatic
python3 manage.py dmp_collectstatic --overwrite
python manage.py collectstatic
python manage.py dmp_collectstatic --overwrite
Setup¶
In your project’s settings.py file, you should have the following. These settings are not specific to DMP, and they are described in the Django documentation.
STATIC_URL = '/static/'
STATICFILES_DIRS = (
BASE_DIR,
)
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
Note that the last line is a serious security issue if you go to production with it (although Django disables it as long as DEBUG=False
). More on that later.
Also in settings.py, ensure you have Django’s static files app enabled:
INSTALLED_APPS = [
...
'django.contrib.staticfiles',
...
]
Linking to Static Files¶
During development, place media files for the homepage app in the homepage/media/ folder. This includes images, videos, PDF files, etc. – any static files that aren’t Javascript or CSS files.
Reference static files using the ${ STATIC_URL }
variable. For example, reference images in your html pages like this:
<img src="${ STATIC_URL }homepage/media/image.png" />
By using the STATIC_URL
variable from settings in your urls rather than hard-coding the /static/
directory location, you can change the url to your static files easily in the future.
Deployment¶
At production/deployment, comment out BASE_DIR
because it essentially makes your entire project available via your static url (a serious security concern):
STATIC_URL = '/static/'
STATICFILES_DIRS = (
# BASE_DIR,
)
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
When you deploy to a web server, run dmp_collectstatic
to collect your static files into a separate directory (called /static/
in the settings above):
python3 manage.py collectstatic
python3 manage.py dmp_collectstatic --overwrite
python manage.py collectstatic
python manage.py dmp_collectstatic --overwrite
Point your web server (Apache, Nginx, IIS, etc.) to serve this folder directly to browsers. For example, in Nginx, you’d set the following:
location /static/ {
alias /path/to/your/project/static/;
access_log off;
expires 30d;
}
In Apache, you’d set the following:
Alias /static/ /path/to/your/project/static/
<Directory /path/to/your/project/static/>
Order deny,allow
Allow from all
</Directory>
dmp-common.js
¶
Open base.htm
and look for the following line:
<script src="/django_mako_plus/dmp-common.min.js"></script>
DMP uses this script to make everything work on the browser side. For example, this script injects values sent from your view.py into the client-side JS scope. It’s a small script (3K), and it’s written in old-school Javascript (for a wide browser audience).
When running in production mode, your web server (IIS, Nginx, etc.) should serve this file (rather than Django). Or it could be bundled with other vendor code. In any case, the file just needs to be included on every page of your site.
The following is an example setting for Nginx:
location /django_mako_plus/dmp-common.min.js {
alias /to/django_mako_plus/scripts/dmp-common.min.js;
}
If you don’t know the location of DMP_on your server, try this command:
python3 -c 'import django_mako_plus; print(django_mako_plus.__file__)'
python -c 'import django_mako_plus; print(django_mako_plus.__file__)'
Advanced Use¶
dmp_collectstatic
will refuse to overwrite an existing /static/
directory. If you already have this directory (either from an earlier run or for another purpose), you can 1) delete it before collecting static files, or 2) specify the overwrite option as follows:
python3 manage.py dmp_collectstatic --overwrite
python manage.py dmp_collectstatic --overwrite
If you need to ignore certain directories or filenames, specify them with the --skip-dir
and --skip-file
options. These can be specified more than once, and it accepts Unix-style wildcards.
python3 manage.py dmp_collectstatic --skip-dir=.cached_templates --skip-file=*.txt --skip-file=*.md
python manage.py dmp_collectstatic --skip-dir=.cached_templates --skip-file=*.txt --skip-file=*.md
If you need to include additional directories or files, specify them with the --include
option. This can be specified more than once, and it accepts Unix-style wildcards:
python3 manage.py dmp_collectstatic --include-dir=global-media --include-dir=global-styles --include-file=*.png
python manage.py dmp_collectstatic --include-dir=global-media --include-dir=global-styles --include-file=*.png
If you have rcssmin
and rjsmin
installed (via pip), DMP will minify your CSS and JS during the collection process. If you are minifying with another tool (webpack, Google’s minifier, etc.), disable minification with:
python3 manage.py dmp_collectstatic --no-minify
python manage.py dmp_collectstatic --no-minify


Course
Java Annotations
Annotations have rapidly became Lorem Ipsum is simply dummy text of the printing and typesetting industry.
197 | | |
Annotations have rapidly became Lorem Ipsum is simply dummy text of the printing and typesetting industry.
In Django Basics, you learned how to set up the skeleton of a video tutorial library. But for a real-world application...
WooCommerce id the leading ECommerce plugin for WordPress and allows you to easily turn any WordPress site into a site..
JavaFX is the de facto way to make Graphical User Interfaces (or GUIs) in Java. It is robust and customizeable, and getting..


Retrieves all or part of the results from a previously executed query. The connection used must have already been established using the macro function SQL.OPEN. Also, a query must already have been executed using SQL.EXEC.QUERY and results must be pending.
If this function is not available, you must install the Microsoft ODBC add-in (XLODBC.XLA).
Syntax
SQL.RETRIEVE(connection_num, destination_ref, max_columns, max_rows, col_names_logical, row_nums_logical, named_rng_logical, fetch_first_logical)
Connection_num is the unique connection ID for a data source. The data source specified must have pending query results. Pending query results are generated by a call to SQL.EXEC.QUERY on the same connection.
If there are no pending results on the connection SQL.RETRIEVE returns the #N/A error value.
If connection_num is not valid, SQL.EXEC.QUERY returns the #VALUE! error value.
Destination_ref specifies where the results should be placed. It is either a reference to a single cell or it is omitted.
If destination_ref refers to a single cell then SQL.RETRIEVE will return all of the pending results in the cells to the right, below, and including destination_ref. This is the same convention used in Microsoft Excel when multiple cells are pasted into a single-cell selection. Any previous values contained in the destination cells will be overwritten without confirmation.
If destination_ref is omitted then the bindings established by previous calls to SQL.BIND will be used to return results. If no such bindings exist for the current connection then SQL.RETRIEVE will return the #REF! error value. If a particular result column has not been bound then its results will be discarded. Max_rows specifies the number of rows that will be returned under each bound column. The first row of results will be placed in the bound cell and any additional rows will be placed in the rows immediately under the bound cell.
Max_columns is the maximum number of columns to be retrieved. It is only used when destination_ref is not omitted.
If max_columns specifies more columns than are available in the results, SQL.RETRIEVE will place data in the columns for which data is available and clear the additional columns.
If max_columns specifies fewer columns than are available in the results, the rightmost result columns will be discarded to fit the chosen size. Column position will be determined by the order in which the data source returned them.
If max_columns is omitted then all of the result columns will be returned.
Max_rows is the maximum number of rows to be returned.
If max_rows specifies more rows than are available in the results, SQL.RETRIEVE will place data in the rows for which data is available and clear the additional rows.
If max_rows specifies fewer rows than are available in the results, SQL.RETRIEVE will place data in the selected rows but will not discard the additional rows. These extra rows can be retrieved via additional calls to SQL.RETRIEVE. This process is described in the fetch_first_logical argument description.
If max_rows is omitted then all rows in the result set will be returned.
Col_names_logical is a logical value which, if TRUE, causes the column names to be returned as the first row of results. It FALSE or omitted, the column names will not be returned.
Row_nums_logical is used only when destination_ref is included. If row_nums_logical is TRUE then the first column in the result set will contain row numbers. If FALSE then row numbers will not be returned. This column of row numbers will not have a column name and the column heading will be left blank. Row numbers can also be retrieved by binding column number 0 with SQL.BIND.
Named_rng_logical is a logical value which, if TRUE, sets each column of results to be declared as a named range on the worksheet. The name of the each range will be the result column name. The named range will only include the rows that were fetched with this SQL.RETRIEVE function call. If FALSE, the results will not be declared as a named range.
Fetch_first_logical is a logical value that allows you to request results from the beginning of the result set.
If the first call to SQL.RETRIEVE did not return all of the rows in the result set then SQL.RETRIEVE may be called again to return the next set of rows. This process can be repeated until no more result rows are available, at which time SQL.RETRIEVE will return the value 0 (zero). This will not halt the running of the macro. During each of these calls, including the first call, fetch_first_logical should be set to FALSE.
If you want to move the cursor back to the beginning of the result set then fetch_first_logical should be set to TRUE. This causes the same SQL query text to be executed again on the data source. The cursor will then be positioned at the top of the result set and SQL.RETRIEVE will fill destination_ref beginning with the first row of results. Further calls to SQL.RETRIEVE, for the purpose of retrieving additional rows, can then be made with fetch_first_logical set to FALSE .
Remarks
Before calling SQL.RETRIEVE a connection must be established with a data source using SQL.OPEN.
If SQL.RETRIEVE is unable to retrieve the results on the specified data source then an error value will be returned. In such a case SQL.RETRIEVE will place error information in memory for the SQL.ERROR function, if such information is available.
If SQL.RETRIEVE is able to successfully return rows of results on the specified connection it will return the number of rows that were actually returned. If there were no results pending on the connection then SQL.RETRIEVE will return the #N/A error value.If no data was found then SQL.RETRIEVE returns 0 (zero).
A successful call to SQL.OPEN returns a unique connection ID number, which is used in a call to SQL.EXEC.QUERY to send a SQL language query. Following this call to SQL.EXEC.QUERY, SQL.RETRIEVE uses the same connection ID number to retrieve query results.
Example
SQL.RETRIEVE(conn1,sheet1!C1,1) stores data obtained from the data source conn1 on Sheet1 from left to right in cell C1, using only column 1.
Related Functions
SQL.OPEN Establishes a connection with a data source
SQL.EXEC.QUERY Sends a query to a data source
SQL.BIND Specifies storage for a result column
SQL.RETRIEVE.TO.FILE Retrieves query results and places them in a file
SQL.GET.SCHEMA Gets information about a connected data source.
SQL.CLOSE Close a data source connection
SQL.ERROR Returns detailed error information
Return to index


Dragon BASIC, online at http://github.com/uli/dragonbasic
Creates a 15-bit, RGB color value from components.ParametersFUNCTION RGB( r, g, b )
r - red component of the RGB value (0-31)Return
g - green component of the RGB value (0-31)
b - blue component of the RGB value (0-31)
A 15-bit, RGB color value.Remarks
Colors created with RGB can be used to create palettes and set entries in palettes as well as plot pixels, lines, etc. in bitmapped modes 3 and 5.See Also
CLS | LINE | PLOT | RGBB | RGBG | RGBR | SETPALENTRY


Add a Match Result
Select next user to add:
Add Player
Player Ranking
{{ player }}
Draw
Submit Result


Product 1
Price
Unit Price
Add
Product 2
Price
Unit Price
Add
Product 3
Price
Unit Price
Add
Product 4
Price
Unit Price
Add


The Clallam County Courthouse was built in 1914 and is located in Port Angeles, Washington. The court house has a bell tower containing a bell which was shipped from Boston all the way around the horn. The building has had at least one addition since it was built. The building uses 126 solar panels, which were installed in 1979, to produce an estimated 20 percent of the electric power needed for the building.
Londonderry is an electoral district of the Legislative Assembly in the Australian state of New South Wales. It is represented by independent MP Bart Bassett who left the Liberal Party of Australia due to ICAC allegations.


File-iteration is a complex, but powerful, vertical repetition construct. It repeatedly includes a file for each number in a user-specified range.
This mechanism requires two pieces of information to operate, a range over which to iterate and a file to include on each iteration.
It can optionally take a third piece of information that represents flags used to discriminate between different iterations of the same file.
This information is obtained through a named external argument called CHAOS_PP_ITERATION_PARAMS
.
Prior to initiating a file-iteration, this macro is defined by the user as a sequence containing (in order) a lower bound, an upper bound, and a filename.
#define CHAOS_PP_ITERATION_PARAMS
(lower)(upper)(file)
Both the lower and upper bounds specify an inclusive range and must be numeric values ranging from 0
to CHAOS_PP_LIMIT_ITERATION
.
(Note that if the upper bound is less than the lower bound, the mechanism will perform the file-iteration in reverse.)
The filename must be a quoted file path (e.g. "file.h"
, as opposed to <file.h>
).
An additional numeric argument may optionally be added.
This argument specifies flags primarily used to distinguish between different iterations of the same file.
If used, the syntax for the definition of CHAOS_PP_ITERATION_PARAMS
becomes
#define CHAOS_PP_ITERATION_PARAMS
(lower)(upper)(file)(flags)
If this element is not specified, the flags are given a default value of 0
.
The lower bound, upper bound, and flags are evaluated parameters. This implies that they can include simple integral constant expressions. For example,
#define N() 5
#define CHAOS_PP_ITERATION_PARAMS
(0)(N() + 5)("file.h")
Once CHAOS_PP_ITERATION_PARAMS
has been properly defined, the mechanism must be initiated.
This is accomplished with
.
CHAOS_PP_ITERATE
??=include CHAOS_PP_ITERATE
()
(The ??=
token is a trigraph for #
.
It is used here to visually disambiguate this inclusion from a normal file inclusion because it is definitely not normal.
The %:
digraph can also provide such disambiguation.
Neither is necessary.)
The following is a complete sample invocation of the file-iteration mechanism:
#defineCHAOS_PP_ITERATION_PARAMS
(1)(10)("file.h") ??=includeCHAOS_PP_ITERATE
()
The above code causes "file.h"
to be included ten times--once for each number ranging from 1
to 10
.
Under normal circumstances, there is nothing particularly useful about including a file ten times.
The difference with file-iteration is that the current macro state changes each time.
For example, the CHAOS_PP_ITERATION
macro can be used to access the current "iteration value".
If "file.h"
contains the following:
// file.h
template<> struct sample<CHAOS_PP_ITERATION
()> { };
and it is iterated as follows:
template<int> struct sample; #defineCHAOS_PP_ITERATION_PARAMS
(1)(5)("file.h") ??=includeCHAOS_PP_ITERATE
()
each inclusion yields different results...
template<int> struct sample; template<> struct sample<1> { }; template<> struct sample<2> { }; template<> struct sample<3> { }; template<> struct sample<4> { }; template<> struct sample<5> { };
(The CHAOS_PP_ITERATION_START
and CHAOS_PP_ITERATION_FINISH
macros can be used to retrieve the lower and upper bounds, respectively, of the current file-iteration.)
The CHAOS_PP_ITERATION_PARAMS
macro is automatically undefined by the library.
There is no reason that a file cannot initiate an iteration of itself.
This has the advantage of keeping related code together.
The problem is that the "regular" section of the file must be discriminated from the iterated section of the file.
The library provides the CHAOS_PP_IS_ITERATING
macro for this purpose.
If a file-iteration is in progress, CHAOS_PP_IS_ITERATING
is defined as 1
.
Otherwise it is not defined.
For example, the following merges the contents of "file.h"
above into the file that iterates it:
// sample.h #if !CHAOS_PP_IS_ITERATING
#ifndef SAMPLE_H #define SAMPLE_H "sample.h" #include<chaos/preprocessor/iteration/file.h>
template<int> struct sample; #defineCHAOS_PP_ITERATION_PARAMS
(1)(5)(SAMPLE_H) ??=includeCHAOS_PP_ITERATE
() #endif // SAMPLE_H #else template<> struct sample<CHAOS_PP_ITERATION
()> { }; #endif
The use of a single file raises another issue.
If the file needs to perform two (or more) separate file-iterations, there must be a way to distinguish between them.
This is the main purpose of the optional flags element in the definition of CHAOS_PP_ITERATION_PARAMS
.
// typelist.h #if !CHAOS_PP_IS_ITERATING
#ifndef TYPELIST_H #define TYPELIST_H "typelist.h" #include<chaos/preprocessor/iteration/file.h>
#include<chaos/preprocessor/recursion/expr.h>
#include<chaos/preprocessor/repetition/enum.h>
#include<chaos/preprocessor/repetition/enum_params.h>
#include<chaos/preprocessor/repetition/enum_shifted_params.h>
#include<chaos/preprocessor/repetition/enum_trailing_params.h>
template<class T> struct identity { typedef T type; } template<class T> struct wrap { }; namespace detail { template<class T> struct unwrap : identity<T> { }; template<class T> struct unwrap<wrap<T> > : identity<T> { }; } template<class = void> struct extract { enum { rogue = -1 }; }; #defineCHAOS_PP_ITERATION_PARAMS
\ (0)(EXTRACT_MAX ? EXTRACT_MAX : 50)(TYPELIST_H)(0x01) \ /**/ ??=includeCHAOS_PP_ITERATE
() namespace primitive { struct nil; template<class T, class U = nil> struct typelist { typedef T head; typedef U tail; }; } template<int = extract<>::rogue> struct typelist; template<> struct typelist<0> { private: enum inaccessible { }; public: template<inaccessible = inaccessible()> struct args { typedef primitive::nil type; }; }; #defineCHAOS_PP_ITERATION_PARAMS
\ (1)(TYPELIST_MAX ? TYPELIST_MAX : 50)(TYPELIST_H)(0x02) \ /**/ ??=includeCHAOS_PP_ITERATE
() #define TYPELIST(args) extract<typelist<> args>::type #endif // TYPELIST_H #elifCHAOS_PP_ITERATION_FLAGS
() == 0x01 #define nCHAOS_PP_ITERATION
() #define unwrap(s, n, _) typename detail::unwrap<T ## n>::type template<template<int> class outputCHAOS_PP_ENUM_TRAILING_PARAMS
(n, class T)> struct extract<output<extract<>::rogue> (CHAOS_PP_ENUM_PARAMS
(n, T))> { typedef typename output<n> ::template args<CHAOS_PP_EXPR
(CHAOS_PP_ENUM
(n, unwrap, ~))>::type type; }; #undef n #undef unwrap #elifCHAOS_PP_ITERATION_FLAGS
() == 0x02 #define nCHAOS_PP_ITERATION
() template<> struct typelist<n> { template<CHAOS_PP_ENUM_PARAMS
(n, class T)> struct args { typedef primitive::typelist< T0, typename typelist<n - 1> ::args<CHAOS_PP_ENUM_SHIFTED_PARAMS
(n, T)>::type > type; }; }; #undef n #endif
Note the use of the optional flags (which is accessed through the CHAOS_PP_ITERATION_FLAGS
macro).
It discriminates between the extract
and typelist
iterations.
typedef TYPELIST((int, double, char, wrap<void>)) abc;
(Note that this TYPELIST
facility maps type elements through parameter types.
For some types, this mapping isn't legal (such as void
).
For others, this causes transformation (such as array types and function types).
For such types, wrap
must be used.)
With variadics (which are not yet part of C++), the TYPELIST
definition would immediately become:
#define TYPELIST(...) extract<typelist<> (__VA_ARGS__)>::type
which would remove the double parentheses clutter:
TYPELIST(int, double, wrap<void>)
However, with variadics, the whole mechanism can be rewritten in other ways that are superior, such as:
#ifndef TYPELIST_H #define TYPELIST_H #include<chaos/preprocessor/facilities/encode.h>
#include<chaos/preprocessor/recursion/expr.h>
#include<chaos/preprocessor/tuple/fold_left.h>
struct nil; template<class T, class U = nil> struct typelist { typedef T head; typedef U tail; }; #define TYPELIST(...) \CHAOS_PP_EXPR
(CHAOS_PP_TUPLE_FOLD_RIGHT
( \ TYPELIST_OP, (__VA_ARGS__), nil \ )) \ /**/ #define TYPELIST_OP(s, type, ...) \ typelist<CHAOS_PP_DECODE
(type), __VA_ARGS__> \ /**/ #endif
This syntactic abstraction is implemented entirely with the preprocessor. For example,
TYPELIST(char, signed char, unsigned char) // typelist<char, typelist<signed char, typelist<unsigned char, nil> > >
With this implementation, there is no need to worry about invalid parameter types or parameter transformations. However, types that syntactically contain open commas must be parenthesized:
TYPELIST(int, (std::pair<int, int>)) // typelist<int, typelist<std::pair<int, int>, nil> >
The file-iteration mechanism supports up to CHAOS_PP_LIMIT_ITERATION_DEPTH
dimensions.
The preceding examples have all used only the first dimension (i.e. the outermost), but the file-iteration mechanism can be invoked again inside an iterated file.
At this point, further explanation is necessary regarding CHAOS_PP_ITERATION
, CHAOS_PP_ITERATION_START
, CHAOS_PP_ITERATION_FINISH
, and CHAOS_PP_ITERATION_FLAGS
.
These primitives expand to the state of the current dimension--regardless of what that dimension is.
If separate files are used for each dimension, then there are no major problems, and using multiple dimensions is straightforward.
However, if more than one dimension is located in the same file, they need to be distinguished from one another.
The file-iteration mechanism provides the macro CHAOS_PP_ITERATION_DEPTH
for this purpose:
// file.h #if !CHAOS_PP_IS_ITERATING
#ifndef FILE_H #define FILE_H #include<chaos/preprocessor/iteration/file.h>
#defineCHAOS_PP_ITERATION_PARAMS
(1)(5)("file.h") ??=includeCHAOS_PP_ITERATE
() #endif // FILE_H #elifCHAOS_PP_ITERATION_DEPTH
== 1 (CHAOS_PP_ITERATION
()) #defineCHAOS_PP_ITERATION_PARAMS
(1)(CHAOS_PP_ITERATION
())("file.h") ??=includeCHAOS_PP_ITERATE
() #elifCHAOS_PP_ITERATION_DEPTH
== 2CHAOS_PP_ITERATION
() #endif
This will result in the following:
(1) 1 (2) 1 2 (3) 1 2 3 (4) 1 2 3 4 (5) 1 2 3 4 5
It is possible to access the state (i.e. the iteration value, etc.) of outer dimensions in two ways--absolutely and relatively.
The first variety accesses a value of a specific iteration frame (i.e. dimension).
To access the iteration value of the first dimension--from any dimension--
is used.
To access the iteration value of the second dimension, CHAOS_PP_FRAME_ITERATION
(1)
is used, and so on.
CHAOS_PP_FRAME_ITERATION
(2)
There are also frame primitives to access the lower bound, the upper bound, and the flags of a specific dimension: CHAOS_PP_FRAME_START
, CHAOS_PP_FRAME_FINISH
, and CHAOS_PP_FRAME_FLAGS
.
The second variety accesses a value of an iteration frame relative to the current frame (e.g. the previous dimension).
These macros take an argument that is interpreted as an offset from the current frame.
For example,
always refers to the iteration value of the next outer dimension.
CHAOS_PP_RELATIVE_ITERATION
(1)
refers to the iteration value of the dimension two frames out, and so on.
(An argument of CHAOS_PP_RELATIVE_ITERATION
(2)0
is interpreted as an offset of 0
and, therefore, causes
to be equivalent to CHAOS_PP_RELATIVE_ITERATION
(0)
.)
CHAOS_PP_ITERATION
()
The lower bound, upper bound, and flags of a dimension can be accessed in this fashion as well with CHAOS_PP_RELATIVE_START
, CHAOS_PP_RELATIVE_FINISH
, and CHAOS_PP_RELATIVE_FLAGS
.
Using relative access to the state of outer dimensions provides the means to produce dimensional abstraction. In certain situations, the dimension is unknown by the code that is being iterated--possibly because the code is reused at multiple, different dimensions.
This example implements a reusable closure facility for C++ that creates function objects out of object references and pointer to member pairs.
It is designed such that implementing operator->*
for a smart pointer is trivial.
Before the closure facility can be implemented, a few metaprogramming facilities must be defined.
The first of these is identity
, a metafunction that evaluates to its argument:
// identity.hpp #ifndef IDENTITY_HPP #define IDENTITY_HPP template<class T> struct identity { typedef T type; }; #endif
The second metafunction, map_integral
, is similar to identity
except that it performs an identity on a constant value instead of a type.
// map_integral.hpp #ifndef MAP_INTEGRAL_HPP #define MAP_INTEGRAL_HPP template<class T, T X> struct map_integral { static const T value = X; }; template<class T, T X> const T map_integral<T, X>::value; #endif
The key motivation for this metafunction is that it maps all integral constants of the same type and value to the same constant variable. Another common possibility is to use an enumerator. However, enumerators are distinct types, which introduces several problems.
First, if the enumeration is unnamed, as in
enum { value = 123 };
then value
cannot be directly used as a templatized argument to a template function because template arguments cannot refer to unnamed types.
export template<class T> void f(T x); void g(void) { return f(value); // error }
Second, if the enumeration is named, it engenders template-produced code bloat.
enum value { value = 123 }; void h(void) { f(123); // T is "int" f(value); // T is "enum value" return; }
Lastly, because enumerations are unique types, operators can be overloaded based on them. Thus, for example, a templatized operator can cut across encapsulation boundaries by converting constant expressions to runtime expressions.
template<class T> struct some_trait { enum value { value = false }; }; template<bool, class T, class F> struct static_if : identity<F> { }; template<class T, class F> struct static_if<true, T, F> : identity<T> { }; template<class T> void f(T x) { typename static_if<!some_trait<T>::value, signed, unsigned>::type var = 0; // ... } // ... template<class T> inline bool operator!(T x) { return !static_cast<bool>(x); }
The third metaprogramming facility that is needed is enable_if
and disable_if
, which selectively disable certain overloads through type substitution failure (SFINAE).
// enable_if.hpp #ifndef ENABLE_IF_HPP #define ENABLE_IF_HPP #include "identity.hpp" namespace primitive { template<bool, class R = void> struct enable_if { }; template<class R> struct enable_if<true, R> : identity<R> { }; template<bool X, class R = void> struct disable_if : enable_if<!X, R> { }; } template<class C, class R = void> struct enable_if : primitive::enable_if<C::value, R> { }; template<class C, class R = void> struct disable_if : primitive::disable_if<C::value, R> { }; #endif
This implementation provides both the primitive version (which operates on a boolean condition) and a higher-level version (suitable for polymorphic metaprogramming).
Only the higher-level disable_if
is actually used.
In order to properly handle issues related to pointers to data members, an is_function
metafunction is required to distinguish function types from all other types.
The following definition works by exploiting type substitution failure (SFINAE) when attempting to form an array of function type:
// is_function.hpp #ifndef IS_FUNCTION_HPP #define IS_FUNCTION_HPP #include "map_integral.hpp" namespace detail { template<class T> class is_function { private: template<class U> static char check(U (*)[1]); template<class U> static char (& check(...))[2]; public: enum { value = sizeof(check<T>(0)) != 1 }; }; } template<class T> struct is_function : map_integral<bool, detail::is_function<T>::value> { }; template<> struct is_function<void> : map_integral<bool, false> { }; template<class T> struct is_function<T&> : map_integral<bool, false> { }; #endif
Another possible implementation is to use the "brute force" approach and define specializations up to some maximum arity of function type. This can be easily accomplished with preprocessor metaprogramming. The weakness of such an implementation is that there is a maximum arity--though it could be so high that the likelihood of the limit causing a practical barrier is infinitesimal. Nevertheless, it is still a blemish from a purist point of view.
There are a few other possibilities as well.
The first of these is attempting to add a cv-qualification to a function type.
This is similar to the above, but with different (and more) specializations for special cases.
In particular, a cv-qualified reference or array cannot be formed, nor can a cv-qualified void
.
#include "identity.hpp" #include "map_integral.hpp" namespace detail { template<class T> class is_function { private: template<class U> static char check(identity<const T>*); template<class U> static char (& check(...))[2]; public: enum { value = sizeof(check<T>(0)) != 1 }; }; } template<class T> struct is_function : map_integral<bool, detail::is_function<T>::value> { }; template<> struct is_function<void> : map_integral<bool, false> { }; template<class T> struct is_function<T&> : map_integral<bool, false> { }; template<class T> struct is_function<T[]> : map_integral<bool, false> { }; template<class T, unsigned long I> struct is_function<T[I]> : map_integral<bool, false> { };
Another possibility is to test whether a conversion from T*
to const volatile void*
exists.
#include "map_integral.hpp" namespace detail { template<class T, class U> class is_convertible { private: static T make(void); static char check(U); static char (& check(...))[2]; public: enum { value = sizeof(check(make())) == 1 }; }; } template<class T, class U> struct is_convertible : map_integral<bool, detail::is_convertible<T, U>::value> { }; template<class T> struct is_function : map_integral<T*, const volatile void*> { }; template<class T> struct is_function<T&> : map_integral<bool, false> { };
One of the drawbacks of this implementation is that many compilers incorrectly allow a conversion from pointer to function to pointer to void
.
However, this implementation, as well as the one that follows, has a more serious drawback.
A final possibility is to exploit a unique property of function types. Specifically, when function types are used as parameter types, they undergo one of the very few forms of compile-time type transformation. They become pointers to functions. Arrays have a similar transformation. When array types are used as parameter types, they are transformed into pointers. These conversions are unlike any other conversion in C or C++. They are pure type-to-type conversions, instead of value-to-value-of-another-type conversions. These conversions are each unique to their respective classes of types. The function type case is exploitable as follows:
#include "map_integral.hpp" template<class T, class> struct is_same : map_integral<bool, false> { }; template<class T> struct is_same<T, T> : map_integral<bool, true> { }; template<class T> struct is_function : is_same<void (T), void (T*)> { }; template<class T> struct is_function<T&> : map_integral<bool, false> { };
This version is the simplest, yet it cannot be used. Both this implementation and the previous implementation are invalid in a particular case where it should work. They cannot handle cv-qualified function types. A cv-qualified function type is not a function type with a cv-qualification added--that is illegal. Rather, a cv-qualified function type is, for example, the type of a cv-qualified member function. More to the point, cv-qualified function types can exist outside of member function types and pointers to member functions. For example,
typedef void function_type(void) const;
is perfectly legal. However, the only thing that can be done with such a typedef is declare a member function or form a pointer to member. This affects the above two implementations significantly because the formation of a pointer to a cv-qualified function type is explicitly prohibited. For this esoteric reason, they are both invalid and are not true function type predicates.
This issue affects the "brute force" implementation as well. For any given arity, eight specializations must be defined--for each cv-qualifier combination and for the presence or lack of trailing variadics (i.e. ellipsis).
(Note also that the "pointer to cv-qualified function" issue is avoided in the first alternative implementation by using identity<const T>*
instead of just const T*
.)
In summary, only the actual implementation above, the "conversion" alternative, and the "brute force" alternative are valid. Of the three, only the first two are fully general. Of those two, the first requires fewer specializations, which makes it the most viable alternative.
Given the above facilities, the closure facility can be implemented.
The resulting syntax for an overloaded member operator->*
should be something like (where ptr_
is an object pointer stored in smart pointer):
template<class M, class C> typename closure<M C::*>::type operator->*(M C::* member) { return make_closure(ptr_, member); }
Similarly, the resulting syntax for an overload non-member operator->*
should be something like:
template<class T, class M, class C> typename closure<M C::*>::type operator->*(const smart_ptr<T>& sp, M C::* member) { return make_closure(&*sp, member); }
These functions must be able to handle pointers to data members as well as pointers to member functions.
(That is the reason for ::type
indirection in the return types.)
The closure
template will have an optional policy parameter that specifies how an object reference is stored and how a raw pointer is retrieved.
template<class T, template<class> class policy = simple> class closure;
This policy is instantiated with a class type (possibly cv-qualified) from a pointer to member type (i.e. the C
in M C::*
).
This instantiation must have a nested type type
that defines the type of storage.
Likewise, it must define a static
member function, get
, that returns a raw pointer.
The default policy, simple
, is defined as follows:
template<class T> struct simple : identity<T*> { static inline T* get(T* obj) { return obj; } };
The closure
specialization to handle pointers to data members requires no repetition and is thus defined as follows:
namespace detail { template<class, class = void> class closure { }; template<class D, class C> class closure< D C::*, typename disable_if<is_function<D> >::type > : public identity<D&> { }; } template<class T, template<class> class policy = simple> class closure : public detail::closure<T> { };
This implementation intentionally disables the specialization (using SFINAE) if T
is not a pointer to data member.
This prevents the specialization from catching pointers to member functions beyond the maximum arity of n--which it otherwise would.
(It also prevents it from catching the esoteric case of variadic member functions that use the ellipsis (...
), which cannot be supported because the variadic arguments cannot be forwarded.)
Further, because of the return type indirection (::type
), the operator->*
will be disabled via SFINAE because the ::type
member does not exist.
Thus, if absolutely necessary, it is possible to manually handle border cases with additional overloads of operator->*
.
The second item of note in this implementation is that it inherits ::type
as a typedef
for D&
.
Corresponding overloads of make_closure
to handle pointers to data members return D&
.
Thus, the implementation of operator->*
directly returns a reference to a data member if the pointer to member it receives refers to a data member.
Note also that a safe add_reference
metafunction (that avoids the reference to reference problem) is not required because it is impossible to form a pointer to reference member, such as
int& C::* member; // illegal
In other words, D
can never already be a reference.
To complete the handling of pointers to data members, several overloads of make_closure
are required.
The only thing that changes from one overload to the next is cv-qualifications, so they will be generated with a file-iteration that iterates over the cv-qualifiers.
The definition that handles const
looks like this:
template<template<class> class policy, class D, class C> inline typename disable_if<is_function<D>, const D&>::type make_closure(typename policy<const C>::type obj, D C::* data) { assert(policy<const C>::get(obj) && data); return policy<const C>::get(obj)->*data; }
These functions simply assert that obj
and data
are both non-null and bind the lvalue produced from applying the built-in operator->*
to the return value reference.
File-iteration is used to generate partial specializations of the primary template closure
to catch various pointer to member function arities with various cv-qualifications.
For example, the specialization for a constant pointer to member function with an arity of two should look like the following:
template<class R, class C, class P0, class P1, template<class> class policy> class closure<R (C::*)(P0, P1) const, policy> { public: typedef closure type; inline closure( typename policy<const C>::type obj, R (C::* func)(P0, P1) const ) : obj_((assert(policy<const C>::get(obj)), obj)), func_((assert(func), func)) { return; } inline R operator()(P0 p0, P1 p1) const { return (policy<const C>::get(obj_)->*func_)(p0, p1); } private: typename policy<const C>::type obj_; R (C::* func_)(P0, P1) const; };
Each specialization defines a constructor that takes an object reference and a pointer to member function which it stores in member variables.
Each specialization also defines an operator()
which is invoked with arguments that, in turn, are forwarded to the member function that is called against the stored object reference.
Note the typedef
that names the closure itself.
In the pointer to member function case, unlike the pointer to data member case, operator->*
must return a function object (i.e. an instance of some closure
specialization) because it does not yet have the arguments to forward to the member function.
At the same time, overloads of make_closure
are generated to catch various pointer to member function arities with various cv-qualifications.
For example, the overload for a constant pointer to member function with an arity of two should look like the following:
template<template<class> class policy, class R, class C, class P0, class P1> inline closure<R (C::*)(P0, P1) const, policy> make_closure(typename policy<const C>::type obj, R (C::* func)(P0, P1) const) { return closure<R (C::*)(P0, P1) const, policy>(obj, func); }
The following is the complete implementation of closure
.
It first defines the specialization for handling pointers to data members.
It then uses file-iteration to iterate over the cv-qualifiers.
During each of these iterations, it defines a make_closure
overload to handle pointers to data members and then performs a nested file-iteration to iterate over function arities.
(The maximum arity defaults to fifteen, but can be increased (or decreased) by defining CLOSURE_MAX_ARITY
.)
Each of these nested iterations defines a function-object specialization of closure
and the corresponding overload of make_closure
.
Finally, it defines an overload of make_closure
for the default policy.
// closure.hpp #if !CHAOS_PP_IS_ITERATING
#ifndef CLOSURE_HPP #define CLOSURE_HPP "closure.hpp" #include<chaos/preprocessor/facilities/unbox.h>
#include<chaos/preprocessor/iteration/file.h>
#include<chaos/preprocessor/repetition/enum_params.h>
#include<chaos/preprocessor/repetition/enum_trailing_params.h>
#include<chaos/preprocessor/seq/elem.h>
#include "enable_if.hpp" #include "identity.hpp" #include "is_function.hpp" #include <cassert> template<class T> struct simple : identity<T*> { static inline T* get(T* obj) { return obj; } }; namespace detail { template<class, class = void> class closure { }; template<class D, class C> class closure< D C::*, typename disable_if<is_function<D> >::type > : public identity<D&> { }; } template<class T, template<class> class policy = simple> class closure : public detail::closure<T> { }; #define cv(n) \CHAOS_PP_UNBOX
(CHAOS_PP_SEQ_ELEM
( \ n, (~)((const))((volatile))((const volatile)) \ )) \ /**/ #defineCHAOS_PP_ITERATION_PARAMS
(0)(3)(CLOSURE_HPP) ??=includeCHAOS_PP_ITERATE
() #undef cv template<class T, class M, class C> inline typename closure<M C::*>::type make_closure(T* obj, M C::* member) { return make_closure<simple>(obj, member); } #endif // CLOSURE_HPP #elifCHAOS_PP_ITERATION_DEPTH
== 1 #define iCHAOS_PP_FRAME_ITERATION
(1) #define get(var) policy<cv(i) C>::get(var) #define object typename policy<cv(i) C>::type template<template<class> class policy, class D, class C> inline typename disable_if<is_function<D>, cv(i) D&>::type make_closure(object obj, D C::* data) { assert(get(obj) && data); return get(obj)->*data; } #defineCHAOS_PP_ITERATION_PARAMS
\ (0)(CLOSURE_MAX_ARITY ? CLOSURE_MAX_ARITY : 15)(CLOSURE_HPP) \ /**/ ??=includeCHAOS_PP_ITERATE
() #undef get #undef object #undef i #else #define jCHAOS_PP_ITERATION
() #define member(id) \ R (C::*CHAOS_PP_UNBOX
(id))(CHAOS_PP_ENUM_PARAMS
(j, P)) cv(i) \ /**/ template< class R, class CCHAOS_PP_ENUM_TRAILING_PARAMS
(j, class P), template<class> class policy > class closure<member(~), policy> { public: typedef closure type; inline closure(object obj, member((func))) : obj_((assert(get(obj)), obj)), func_((assert(func), func)) { return; } inline R operator()(CHAOS_PP_ENUM_PARAMS
(j, (P, p))) const { return (get(obj_)->*func_)(CHAOS_PP_ENUM_PARAMS
(j, p)); } private: object obj_; member((func_)); }; template< template<class> class policy, class R, class CCHAOS_PP_ENUM_TRAILING_PARAMS
(j, class P) > inline closure<member(~), policy> make_closure(object obj, member((func))) { return closure<member(~), policy>(obj, func); } #undef member #undef j #endif
When the default maximum arity of fifteen is used, the file-iteration generates sixty-four specializations of closure
and sixty-eight overloads of make_closure
(which represents a whole lot of avoided manual repetition).
Finally, the following program implements a trivial smart pointer that defines operator->*
.
It also implements operator->*
for std::auto_ptr
and boost::shared_ptr
.
// main.cpp #include "closure.hpp" #include <boost/shared_ptr.hpp> #include <iostream> #include <memory> template<class T, class M, class C> inline typename closure<M C::*>::type operator->*(const std::auto_ptr<T>& sp, M C::* member) { return make_closure(sp.operator->(), member); } template<class T> struct shared : identity<boost::shared_ptr<T> > { static inline T* get(boost::shared_ptr<T> sp) { return sp.get(); } }; template<class T, class M, class C> inline typename closure<M C::*, shared>::type operator->*(boost::shared_ptr<T> sp, M C::* member) { return make_closure<shared>(sp, member); } template<class T> class dumb_ptr { private: T* ptr_; public: inline dumb_ptr(T* ptr) : ptr_(ptr) { return; } inline ~dumb_ptr(void) { delete ptr_; return; } template<class M, class C> inline typename closure<M C::*>::type operator->*(M C::* member) { return make_closure(ptr_, member); } }; struct Q { inline Q(int x = 0) : x(x) { return; } int x; int f(void) { return x; } }; int main(void) { int Q::* px = &Q::x; int (Q::* pf)(void) = &Q::f; Q var; Q* a = &var; a->*px = 1; std::cout << (a->*pf)() << '\n'; std::auto_ptr<Q> b(new Q); b->*px = 2; std::cout << (b->*pf)() << '\n'; boost::shared_ptr<Q> c(new Q); c->*px = 3; std::cout << (c->*pf)() << '\n'; dumb_ptr<Q> d(new Q); d->*px = 4; std::cout << (d->*pf)() << '\n'; return 0; }
Note that unlike the built-in closures formed by operator->*
(and .*
), closure
objects can be passed around or stored, which introduces a potential loophole into a reference-counted smart pointer like boost::shared_ptr
.
That is why the default policy parameter is overridden such that closure
objects store an instance of boost::shared_ptr
instead of a raw pointer.
(If a smart pointer already provides an implicit conversion to pointer type, then there should be no need for an overload of operator->*
unless storing or otherwise manipulating the closure is desired.
The built-in operator->*
should be chosen by the compiler and the implicit conversion performed on the left operand.
The only disadvantage that the built-in operator has is that its result has no type.
Otherwise, it has no arity limitations (including variadics) and it does not require forwarding.
Of course, there are disadvantages to providing an implicit conversion from a smart pointer to a pointer.)


PokéStops are important or iconic places around your area: They may be special benches with dedication plaques, permanent art installations, or historic landmarks. They'll never be something as mundane as a stop sign, nor will they be in a location that is not accessible to the public — like something inside a private building, or beyond a locked gate.
PokéStops are an easy way to collect items, experience, and Poké Eggs (which hatch into Pokémon with the help of incubators, which we'll talk about later).
They're indicated on your map by tall poles with blue cube atop them: You can tap one even if you're not in range to find out which landmark they're associated with, but you won't be able to check in until you're close to the PokéStop.
When a PokéStop is within range, the blue cube will transform into a spinning disc, which you can tap on to visit. Inside, you'll see the PokéStop symbol with a disc in the middle that displays the location's photo; you may also get some historical information about the monument, if you're into that sort of thing.
Swipe the disc to spin it, and you'll be rewarded with a variety of items. Items can include Poké Eggs, Poké Balls, healing potions, and more. As you increase in levels, you unlock new items to collect.
After you visit a PokéStop, the blue pole will change to purple, and you'll be unable to visit for at least 10 minutes.


When the selected date is greater than specified date. The field validator will raise an error.
Click the calendar image on the right side.
This example shows how to restrict the user to select only ten days from now.
This example shows how to customize the datebox buttons underneath the calendar.
Click the calendar image on the right side.
Different date formats are applied to different DateBox components.
This example shows how to set the width of DateBox to a percentage of its parent container.
width: 50%
width: 30%
Multiple datebox components can share a calendar and use it to pick dates.
| Start Date: | End Date: |


Let's load some sweet webfonts...
Some lovely text that uses the fallback font
Some lovely text that uses a CORS font


Jumia Technologies (JMIA) Presents At RBC Global Technology, Internet, Media and Telecom Conference - Slideshow
by SA Transcripts, https://seekingalpha.com/author/sa-transcriptsThe following slide deck was published by Jumia Technologies AG in conjunction with this event.


{% extends "admin/change_list.html" %} {% load admin_list %} {% load core_tags %} {% block content_title %}
| {{ row.owner__username | default:'-' }} | {{ row.application_template__nice_name | default:'-' }} | {{ row.spawner_cpu | spawner_cpu }} | {{ row.spawner_memory | spawner_memory }} | {{ row.min_runtime | default:'-' }} | {{ row.max_runtime | default:'-' }} | {{ row.total_runtime | default:'-' }} | {{ row.num_with_runtime }} | {{ row.num_launched }} |
| Overall | {{ summary_total.min_runtime | default:'-' }} | {{ summary_total.max_runtime | default:'-' }} | {{ summary_total.total_runtime | default:'-' }} | {{ summary_total.num_with_runtime }} | {{ summary_total.num_launched }} |
Applications launched before mid September 2019 will not have their runtime, CPU or memory included in this report. Applications launched after mid September 2019 will have their CPU and memory included just after launch, and their runtime included a few minutes after they have stopped.


Creating friendships with food, drink and conversation
{% if session.user %} Supper Club {% else %} Register {% endif %}
"An underground restaurant, sometimes known as a supper club or closed door restaurant, is a social dining restaurant
operated out of someone's home. They are usually advertised by word of mouth."
The origin of supper clubs is unknown, however, most believe that it was first stumbled across by the western world in Cuba
in the early 2000's. The concept was brought over to the UK before exploding in popularity in countries such as
South Africa and the Netherlands.
Cook House believe that the best friendships are made over sharing a good meal, and with today's amateur culinary world exploding
we wanted to create a platform that would allow foodies alike to eat, drink and laugh together.
We would love all of our users to try out hosting as we believe it to be one of the most rewarding experiences. Once registered follow
the Create Event link and here you can advertise your Supper Club to our registered users.
It's simple and you can add as much information as you choose, we do however require an event name, location, cuisine, date, menu and any
additional extras. Your menu is up to you, as many courses as you'd like, or sharing style anything goes and we've seen it all!
Search for supper clubs near and far. Overnight stays, city breaks, weekends by the coast these are all perfect opportunities to experience
an incredible evening put on by a local host. You can enjoy world class food without the price tag and meet some truly interesting people.
Once you've chosen a supper club register your interest and make sure to inform the host of any dietary requirements. If you have any questions
on the event this is your time to ask the host or us. Don't be afraid to ask we all understand this is a new experience for most.


gene genes genome chloroplast ancestral reinhardtii order genomes orders rearrangements functional inferred random .(.) clusters clustering number observed Chlamydomonas {border-style cpDNA data vulgaris px;} rpl- #ffffff;} rearrangement file selection test using breakage inversion sidedness cpDNAs functionally large model related Additional green land lineage Figure Proc GRAPPA Mol Sci analysis copy repeat simulated structure (Figure Acad DNA Natl RNA common conserved increased phylogeny sequences Biol blocks branch changes cluster evolution evolutionary inversions leading null plastid possible reconstruction regions relative shown strand total transposition Genet Turmel [GenBank: inverted plant px; rate region repeats seven shared {font-family Gene Lemieux Plant additional analyses approach chlorophyte co-transcription directional expected expression font-size genomes, increase index plants reinhardtii. set single transcription used Chloroplast DNAs Moret Res Stern ancestor associated bootstrap chromosome clustered degree distribution double; eukaryotic extant highly hypothesis multiple new phylogenetic rearranged rearrangements. sequence sets similar simulation (see ./BF ATP B). Click Evolutionary File Genome LINK LSC Mesostigma Palmer SSC Text Wang alga bold border-color border-width breakpoint category chloroplasts chromosomal clusters, compared computed conducted content decrease dispersed events evidence file, genes. genome. influence involved level lineages model. natural neighboring nucleotide order. proteins rRNA ratios scale selective significantly simulations small solid; study true vulgaris, {font-style {font-weight Ancestral Chlorella Co-transcription Cui Evol Genomic However, Kolmogorov-Smirnov Methods). NC_]) New Otis Science Tang Wolfe [], accuracy accurate algae based branches calculated charophyte coding concatenated contain contents courier; defined distance duplications em; encoded estimation experimental generally genomes. include included including influenced inversions, kb) lost maximum mouse neutral novel opposite organization psaA pt;} rearrangements, reflect replicates results ribosomal scored species study, support time transpositions tree variation work


time
HTML5, published on October 28 2015, has really good accessibility.

HTML5, published on <time datetime="2015-10-28">October 28 2015</time>, has really good accessibility.


Thank you for installing!
Congratulations! You're now raising money for charity with every new tab you open!
Do you have an AdBlocking service installed?
Click here to whitelist Charity Tabs


Search Results
No. of rows : {{ count }}
Earthquakes that occurred at night
{% for rows in data %}
{{ rows }}
{% endfor %}
No. of rows : {{ count2 }}
Earthquakes that occurred at day
{% for rows2 in data2 %}
{{ rows2 }}
{% endfor %}
{% if count > count2 %}
Large earthquakes occurs often at night
{% else %}
Large earthquakes do not occur often at night
{% endif %}


When you add a new game, you are giving us permission to publish this content. New content will credit the author(s) by their chosen Username, no personal details other than that will be shared.
We cannot guarantee your game will be accepted. But if it does be sure to check it out on the games tab. Thank you! That’s the Spirit community!


Performs fast detection of interactions in large-scale data using the method of random intersection trees introduced in Shah, R. D. and Meinshausen, N. (2014) <http://www.jmlr.org/papers/v15/shah14a.html>. The algorithm finds potentially high-order interactions in high-dimensional binary two-class classification data, without requiring lower order interactions to be informative. The search is particularly fast when the matrices of predictors are sparse. It can also be used to perform market basket analysis when supplied with a single binary data matrix. Here it will find collections of columns which for many rows contain all 1's.
| Version: | 0.1.2 |
| Imports: | Rcpp, Matrix, methods |
| LinkingTo: | Rcpp |
| Published: | 2017-04-03 |
| Author: | Hyun Jik Kim, Rajen D. Shah |
| Maintainer: | Rajen D. Shah <r.shah at statslab.cam.ac.uk> |
| License: | GPL-2 |
| URL: | http://www.jmlr.org/papers/v15/shah14a.html |
| NeedsCompilation: | yes |
| SystemRequirements: | C++11 |
| CRAN checks: | FSInteract results |
| Reference manual: | FSInteract.pdf |
| Package source: | FSInteract_0.1.2.tar.gz |
| Windows binaries: | r-devel: FSInteract_0.1.2.zip, r-release: FSInteract_0.1.2.zip, r-oldrel: FSInteract_0.1.2.zip |
| OS X binaries: | r-release: FSInteract_0.1.2.tgz, r-oldrel: FSInteract_0.1.2.tgz |
| Old sources: | FSInteract archive |
Please use the canonical form https://CRAN.R-project.org/package=FSInteract to link to this page.