- Create the functionality to browse local Concerts, and store a location.
- Create Modal for concert information and the external link to the TicketMaster website.
- Add functionality to Login and have user made accounts.
- Add functionality to save concerts as a signed in user.
- Add the ability as a logged in user to add bands to a curated favorites list.
- Within the favorite bands page, add the functionality to see upcoming concerts.


We’ll Deliver the best stories and ideas on the topics you care about most straight to your homepage, app, or inbox.
Deliver the best stories and ideas on the topics you care about most straight to you.
Deliver the best stories and ideas on the topics you care about most straight to you.
Deliver the best stories and ideas on the topics you care about most straight to you.
Deliver the best stories and ideas on the topics you care about most straight to you.
Deliver the best stories and ideas on the topics you care about most straight to you.
Deliver the best stories and ideas on the topics you care about most straight to you.
功能一
功能二
功能三
功能四
功能五
功能一
功能二
功能三
功能四
功能五
功能一
功能二
功能三
功能四
功能五
功能一
功能二
功能三
功能四
功能五


The University of Sheffield (Sheffield, United Kingdom) held the first Sheffield GPU Hackathon on August 19-23, 2019 at Halifax Hall at Sheffield, United Kingdom. The University of Sheffield partnered with NVIDIA and Oak Ridge Leadership Computing Facility (OLCF) to hold its first GPU hackathon, where seven applications teams worked alongside mentors with GPU-programming expertise to accelerate their scientific codes using GPUs.
Following the success of the first Sheffield GPU Hackathon, in 2020 we will once again bring together team of application developers some with little or no previous GPU programming experience to get their own codes running on GPUs, or to optimise their codes that currently run on GPUs, using OpenACC or other parallel programming models.
To read more about some success stores from the 2019 event please read the blog post on the RSE Sheffield website.


This documentation gives you a roadmap and tutorial on how to do visual computing in C++ on Android. We will not cover much Java development here, for that see http://developer.android.com, but we do cover how Java and C/C++ interact via JNI (Java Native Interface). Most of this document is relevant for native (C/C++) development on any Android device, some only on NVIDIA Tegra devices, and even a smaller subset only on NVIDIA Cardhu developer board.
Table of contents:


$\unicode{x2A0D}$ $\require{bad_extension}$This procedure is simply a generalization of the method used in Sects. 1-3 and 1-4 to obtain the equations of the osculating plane and the osculating circle. Let $f(u)$ near $P(u=u_0)$ have finite derivatives $f^{(i)}(u_0)$, $i = 1, 2, \ldots, n+1$. Then if we take $u=u_1$ at $A$ and write $h = u_1 - u_0$, then there exists a Taylor development of $f(u)$ of the form (compare Eq. (1-5)): $$ f(u_1) = f(u_0) + hf'(u_0)+{h^2\over 2!}f''(u_0) + \cdots + {h^{n+1}\over (n+1)!}f^{(n+1)}(u_0) + o(h^{n+1}). $$ Here, $f(u_0)=0$ since $P$ lies on $\Sigma_2$, and $h$ is of order $AP$ (see theorem Sec. 1-2); $f(u_1)$ is of order $AD$. Hence necessary and sufficient conditions that the surface has a contact of order $n$ at $P$ with the curve are that at $P$ the relations hold: $$ f(u) = f'(u) = f''(u) = \cdots = f^{(n)}(u) = 0;\quad f^{(n+1)}(u) \ne 0. $$


TINT2(1) TINT2(1) NAME tint2 - lightweight panel/taskbar SYNOPSIS tint2 tint2 -c /path_to_config_file DESCRIPTION This manual page documents briefly the tint2 command. tint2 is a simple panel/taskbar intentionally made for openbox3, but should also work with other window managers. It's based on ttm code. The goal is to keep a clean and unintrusive look with code lightweight and compliance with freedesktop specifications. On the first startup tint2 creates a config file in $HOME/.con‐ fig/tint2/tint2rc. See wiki page on http://code.google.com/p/tint2/wiki/Welcome for more information. OPTIONS -c config-file Specify which configuration file to use instead of the default. AUTHOR tint2 was written by Thierry Lorthiois<EMAIL_ADDRESS>It is based on ttm, originally written by PÃ¥l Staurland<EMAIL_ADDRESS>This manual page was written by Daniel Moerner<EMAIL_ADDRESS>for the Debian project (but may be used by others). It was adopted from the tint2 docs. 2009-01-17 TINT2(1)


Co-op
Focused on designing and developing an Android Kotlin library to streamline the use of multiple geographic map providers like Google Maps, HERE Maps, and AutoNavi Maps through a common declarative API. Also worked on developing an Android app for employees to make snack purchases using their phones and analyzing battery impact of FindMate feature with Android Oreo behavioral changes in the Mini Connected app.
Summer Internship
Worked primarily on BMW Connected Android app refactoring legacy login system and deploying smartphone testing farm for remote testing and automated UI testing. Documented solutions to common build issues. Helped identify issues with web app that prevented customers from using the Android app.


Advanced Layouts
Every collection view relys on a CollectionViewLayout
object to provide the information. This allows a layout object to reason about the desired layout in whatever way is most appropriate for its goal. Every layout is a subclass of CollectionViewLayout
, an abstract class that provides the framework for collection view to access information it needs to display each item correctly.
A few layouts are provided and allow for customization. We’ll go through each of these layouts and some of the tips and tricks of each then discuss building your own layout.
CollectionViewListLayout
CollectionViewListLayout is a simple vertical list similar to an NSTableView/UITableView.
Some of the key customization tips for this layout are the interitemSpacing
and sectionInsets
. Also available via CollectionViewDelegateListLayout methods for per section values, these properties can turn an ordinary list into a card style list with minimal effort.
CollectionViewColumnLayout
CollectionViewColumnLayout organizes items in each section into columns creating a grid or a pintrest style waterfall depending on your setup.
Coumns and Width
Your first choice is how many columns should be used in a given section. This number in conjunction with column spacing and section insets will determin the width of each item. In the example below our collection view is 800pt wide, with insets of 10 and column spacing of 10 wit 5 columns. This leaves 88pts for each cell, remember at this stage we are only worried about width.
Columns are always equal width and adjusting the spacing, insets, or number of columns will affect the width of each column equally.
Item Height
With the itemWidth set by the column, you have 3 options to set the height of each item. The first option to return a value is used meaning if aspectRatioForItemAtIndexPath
is implemented it is used, otherwise, it checks the next one.
aspectRatioForItemAtIndexPath
(delegate): Set the height as a ration of the width. For example height = 1:2 * calculatedWidth. value of 0 is ignoredheightForItemAtIndexPath
(delegate): Set the height to an exact value.layout.defaultItemHeight
: A default height to use if the delegate does not supply a value
A special case also exists if both a ratio and a height are returned by the delegate. in this case a height will be calculated by the ratio and added to the static height from heightForItemAtIndexPath
. Considering the example above with a item width of 88 the following examples are valid where ratio and height represent the values returned by the associated delegate method:
ratio = 1:2 (44)
height = 0
itemHeight = 44
ratio = 0:0 (0)
height = 50
itemHeight = 50
ratio = 1:2 (44)
height = 20
itemHeight = 64
When heights are consistent for each item, the items will display in a grif formation. When items vay in height they will take on a waterfall appearance, each item pinning to the previous item in the column. By default items are placed in columns from left to right. This is controlled by the itemRenderDirection
and can be set to rightToLeft
or shortestFirst
.
CollectionViewFlowLayout
A variation of UICollectionViewFlowLayout. This layout is primarily row based, but uses ItemStyles to group similar items together.
#### Styles
Flow layout uses styles to group items. The layout’s delegate, CollectionViewDelegateFlowLayout
, is responsible for providing a style for each item in the collection view. The styles are similar but can be used to create or break groupings based on size.
Flow items are grouped together, always placing as many same height items in each row as possible. If the row becomes full or an flow item of a different height is provided, the layout will just to the next row and continue.
Span items are always placed an their own row and fill the width of the Collection View.
Here you can see an example of how the firt two rows are created by grouping items with the same height. If the third item in the first row had a height of 80, it would have been moved to its own row. New rows will be created when either there is no room left for the next item, the item has a different height than the preceeding ite, or the item is a span.
Transformations
By default items are presented at the given size and left aligned. Transformations allow you to adjust the content of each row before moving on to the next row.
The center
transformation will shift the contents in a row to be center aligned without changing the size of any items.
The fill
tranformation will enlarge the items in a row proportionally to fill the row. If the items have already filled the row, no tranformation occurs. Note that this change the size of the items from the size provide by the items style and will affect the height of the entire row.
Spacing
Spacing options such as interspanSpacing
and spanGroupSpacingBefore
allow you to customize the space around different types of style groups.
The spanGroupSpacingBefore/After options will apply a set amount of space before or after a group of span items (one or more spans).
Custom Layouts
Layouts are designed to make just about arrangment of a collection views contents possible. Creating a new layout requires subclassing CollectionViewLayout
and overriding its methods to be able to return the necessary data to the collection view when requested.
That said, it is important to prepare and deliver this data as efficiently as possible. The collection view relies on the layout to determine the location of items and what items exist at particular locations and requests this data often. Doing too much work to detmine this data can lead to slow performance while interacting with the collection view, including scrolling.
The first step in avoiding redundant calculations in a layout is to prepare as much as possible up front. The prepare
method should be overriden to do this work. Typically this involved calculation item attributes and caching them for quick reference when requested by the collection view.
For more in depth details about creating a collection see the CollectionViewLayout
documentation and refer to the provided layouts.


View my favourite Poetry anthology
Create
id
Title
Author
Price
Update
Delete
Create a
update
Poems
Title
Author
Price
Create
Update


Karina is a smart and adaptive web developer, who first learned to code in 2014 by taking a computer science class at her university, Cal Poly San Luis Obispo. After discovering a passion in coding, she moved to New York City and attended Dev Bootcamp in 2015. After graduating, Karina moved back to her hometown Los Angeles where she found her first job at Creativengine, creating websites and web apps for Congress. She worked Refiinery29, a consumer media web platform, for two years. She is now employed at Better, a mortgage company.


🌎
EPOD
Backward
Forward
loading...
This is a mobile web friendly mirror of
EPOD
.
epod-mobile
by
yuzawa-san
Source
|
License


Enter bank details
Standard pattern
Use this when:
- the user needs to give details of the bank account they want to receive payment
Your bank details
View code snippet
Alternative pattern 1
Use this when:
- you want the user to consider which account they want the money paid into
Research notes
User research for Get your State Pension found that asking people whether they want to be paid into a bank account or a building society account makes them think about whether they need their pension for everyday spending or for savings.
Your payment details
How would you like to get paid?
View code snippet

Your payment details

How would you like to get paid?

<form>
<fieldset>

<input id="bank-account-yes" type="radio" name="account-select" value="bank">
Bank account

<input id="building-society-yes" type="radio" name="account-select" value="building">
Building society account

</fieldset>

<fieldset>

Account holder name

<input type="text" class="form-control" id="account-name" name="account-name">
</fieldset>

<legend class="form-label-bold">Sort code</legend>

<fieldset>

<input class="form-control" id="sort-code-1" maxlength="2" name="sort-code-1" type="text" />

<input class="form-control" id="sort-code-2" maxlength="2" name="sort-code-2" type="text" />

<input class="form-control" id="sort-code-3" maxlength="2" name="sort-code-3" type="text" />

</fieldset>

<fieldset>

Account number

<input type="text" class="form-control" id="account-number" name="account-number">
</fieldset>

<fieldset>

Building society roll or reference number
If your building society uses a roll or reference number, you will find it on your passbook

<input type="text" class="form-control" id="bs-society-roll" name="bs-society-roll">
</fieldset>

<input type="submit" class="button" value="Continue">
</form>
Alternative pattern 2
Use this when:
- you need to know whether the user has a bank account to receive payment
Research notes
User research for Carer’s Allowance found that some people don’t have a bank account. They needed to be able to complete the transaction without providing any bank details.
Your bank details
Carer’s Allowance can be paid into a UK bank account, either your own or someone else’s, or your own Post Office card account. You’re responsible for repaying any overpayments, even if the money is paid into someone else’s account
View code snippet

Your bank details

Carer's Allowance can be paid into a UK bank account,
either your own or someone else's, or your own Post Office card account.
You're responsible for repaying any overpayments, even if the money is
paid into someone else's account
<form>
<legend>Do you have a bank account?</legend>
<fieldset class="inline">

<input id="bank-account-yes2" type="radio" name="account-select" value="Yes">
Yes

<input id="bank-account-no2" type="radio" name="account-select" value="No">
No

</fieldset>

<fieldset>
Account holder name
<input type="text" class="form-control" id="ba-account-holder" name="ba-account-holder" value="">
</fieldset>

<legend class="form-label-bold">Sort code</legend>

<fieldset>

<input class="form-control" id="ba-sort1" maxlength="2" name="ba-sort1" value="" type="text">

<input class="form-control" id="ba-sort2" maxlength="2" name="ba-sort2" value="" type="text">

<input class="form-control" id="ba-sort3" maxlength="2" name="ba-sort3" value="" type="text">

</fieldset>

<fieldset>

Account number

<input type="text" class="form-control" id="ba-account-number" name="ba-account-number" value="" maxlength="10">
</fieldset>

<fieldset>

Building society roll or reference number (optional)
If your building society uses a roll or reference number, you will find it on your passbook

<input type="text" class="form-control" id="bs-society-roll" name="bs-society-roll" value="" data-required="true">
</fieldset>

You won't be paid Carer's Allowance without a bank account.

You can add bank details after you apply by contacting the Carer's Allowance Unit.

</form>


Department of Computer Engineering
The Computer Engineering Department is established in 1994. The department continuously strives to comply with the emerging technologies in the area of Computer. The department runs undergraduate and post graduate program. Computer department is highly proud of having qualified, dedicated and experienced staff. The staff attempts usage of various methodologies to enhance the understanding of the course to the students in the department. Besides conventional methods of teaching like lectures and tutorials, the staff encourages students to learn concepts of the course through workshops, group discussions, group projects and quiz etc. the faculty in the department is also involved in research in their specialized areas and department supports faculty to expertise the subject.
The department started with an initial intake of 40 students in UG program and during the course of time, now it has been enhanced to 120. In 2011, the department started a PG program with an intake of 18 students and research center with intake of 10 student has also started in the department since 2015-16.
The department is headed by Dr.Subhash Shinde. His area of interest includes Mobile and wireless communication, soft computing techniques and optimization. The Head of department has rich experience of working at various level through his academic and industrial career.
Computer Society of India - Student Chapter LTCOE
Computer Society Of India is formed in 1965 that has been instrumental in guiding the Indian IT industry down the right path since its formative years. Today, the CSI has 70 chapters all over India, 358 student branches, and more than 90,000 members, including India's most famous IT industry leaders, brilliant scientists and dedicated academicians.
The mission of the CSI is to facilitate research, knowledge sharing, learning and career enhancement for all categories of IT professionals.
The CSI is also working closely with other industry associations, government bodies and academia to ensure that the benefits of IT advancement in india.
The department is headed by Dr. Subhash Shinde . His area of interest includes Mobile and wireless communication, soft computing techniques and optimization. The Head of department has rich experience of working at various level through his academic and industrial career.
Computer Engineeering Students Associtaion
The Computer Engineering Department is established in 1994. The department continuously strives to comply with the emerging technologies in the area of Computer. The department runs undergraduate and post graduate program. Computer department is highly proud of having qualified, dedicated and experienced staff. The staff attempts usage of various methodologies to enhance the understanding of the course to the students in the department. Besides conventional methods of teaching like lectures and tutorials, the staff encourages students to learn concepts of the course through workshops, group discussions, group projects and quiz etc. the faculty in the department is also involved in research in their specialized areas and department supports faculty to expertise the subject.
The department started with an initial intake of 40 students in UG program and during the course of time, now it has been enhanced to 120. In 2011, the department started a PG program with an intake of 18 students and research center with intake of 10 student has also started in the department since 2015-16.
The department is headed by Dr. Subhash Shinde. His area of interest includes Mobile and wireless communication, soft computing techniques and optimization. The Head of department has rich experience of working at various level through his academic and industrial career.


Enjoy hasel free, uninterrepted, scores notification right on your desktop :)


| Created: | 6/27/2020 7:03:34 AM |
| Modified: | 6/27/2020 7:03:34 AM |
| Project: | |
| Advanced: |
| Attribute |
|
Public serial id |
|
Details:
|
|
Public integer sco_recon_id |
|
Details:
|
|
Public integer[] bucket_ids |
|
Details:
|
|
Public integer rank |
|
Details:
|
|
Public varchar(255) created_by |
|
Details:
|
|
Public timestamp with time zone(0) created_at |
|
Details:
|
|
Public timestamp with time zone(0) updated_at |
|
Details:
|
|
Public varchar(255) updated_by |
|
Details:
|
|
Public timestamp with time zone(0) start_date |
|
Details:
|
| Operation | ||
|
Public sco_recon_versions_pkey( id: serial, |
||
|
Details:
<<PK>>
|
||
|
Public sco_recon_versions_sco_recon_id_foreign( sco_recon_id: integer, |
||
|
Details:
<<FK>>
|
| Element | Source Role | Target Role |
|
«table» sco_recons Table «FK» |
Name: sco_recon_versions_sco_recon_id_foreign |
Name: sco_recons_pkey |
|
Details:
|
| Tag | Value |
| Owner | public |
|
Details:
|
| Property | Value |
| isFinalSpecialization: | 0 |


In the course of developing, testing and distributing your app, different types of builds are produced. If you test these on a device, one might overwrite the other, or even a live version you’ve downloaded from the app store just to make sure everything works. In this post, I’ll propose some simple strategies to keep all of those builds separate and easily distinguishable on your test devices.
First things first: prevent debug, beta, and app store builds from overwriting each other on your test device. To do this, add a suffix to each of your non-app-store builds so they register as “different” apps on your iDevice. Here’s my setup:
Once you have multiple versions of your app on your device beside each other, you need a way to tell them apart. Inspired by Krzysztof Zabłocki’s KZBootstrap, I wanted to overlay some information about each build onto the icons, depending on the build variant. While KZBootstrap
seems like an amazing tool, I already had an Xcode project, and I wanted to insert a clean, minimal solution. I also didn’t want to bring any new dependencies in, like imagemagick
and ghostscript
as in KZBootstrap
and a few other solutions I found online.
After a little more searching, I found XcodeIconTagger
which only uses macOS’ Automator with a Quartz filter. I modified it to get a little more flexibility out of it in this fork. Now, I can create Run Script Build Phases surrounding the Copy Bundle Resources Build Phase that first create the icon overlay, and then after copying the icons to the installation, reset the git index to discard the changes.
tag-icons.sh
is a script that wraps some of the different types of overlays I’d like, depending on the build variant, into a convenient interface to which I can simply supply either tag
or cleanup
commands. (It can be found in shared-utils.) The conditional logic that decides what to display, and invocation of the underlying tool itself, is handled inside:
Now, I can tell all my builds apart on my device at once. Here I have a debugging development build, displaying the git commit hash that built it; a beta build, showing the semantic and build versions; a special build that visualizes touch input, which I use to create App Store preview videos; the App Store version itself, with no overlay.
🙏🏻 Enjoy the post? Please help support more like it by buying me a cup of coffee!.
💡 Suggestions, questions, comments? Please submit a PR!.


@(user: models.user.User)@layout.bootstrap("Submit") { @(_navBar(user,"home"))
View contests - TODO
Search and select active contests


Please confirm your phone number and address are updated and accurate to ensure proper Service.
If you are searching for a Maid aka "Bai" then you are at the right place! We have made it easy to hire a full time or part time maid in your city!
We provide an on-demand hour- based housekeeping service which includes dusting , mopping the floors, cleaning, washing clothes & sanitizing your bathrooms.
This is the most basic & tedious work on your list – daily Cleaning! Our maids will take over your home & make it cleaner than ever everyday!
Our maid will mop your kitchen floor, wipe the slabs and clean cabinets outside & inside which will bring back the shine in your kitchen. Moreover, she can even cook the food for you!

Right and Left,Up and Down, we sweep and mop all-around your house for a dirt & germ free hygienic environment .
{{ detailAnnouncement }}


A cloud-based infrastructure for managing, analyzing and sharing genomics datasets.
Bionimbus is a collaboration between the Institute for Genomics and Systems Biology (IGSB) at the University of Chicago and the Open Science Data Cloud to develop open source technology for managing, analyzing, transporting, and sharing large genomics datasets in a secure and compliant fashion.
The Bionimbus Protected Data Cloud (PDC) is a collaboration between the Open Science Data Cloud and the IGSB (IGSB), the Center for Research Informatics (CRI), and the Institute for Translational Medicine (ITM) at the University of Chicago. The PDC allows users authorized by NIH to compute over human genomic data from dbGaP in a secure compliant fashion. Currently, selected datasets from the The Cancer Genome Data Center (TCGA) are available in the PDC.
Version 2 of Bionimbus is used by the IGSB and their collaborators to manage data from the IGSB's High-Throughput Genome Analysis Core (HGAC). Version 3 of Bionimbus is beta and uses some of the OSDC's common core services.


WELCOME TO HOSPITAL MANAGEMENT SYSTEM
Patient Information
php echo "hello";?>
$con=Mysqli_connect("localhost","root","","hospital_management");
if($con)
{
echo "connection sucessful";
}
else
{
echo "connection not sucessful";
}
$query="Select * from patient_registration";
$select=mysqli_query($con,$query);
if(select)
{
echo "selected";
}
mysqli_close($con);
?>


Ocean [aj36], ocean, in The Inner Sea ------------------------------------------------------------------------ 30: The fog has cleared. Routes leaving Ocean: North, to Ocean [ai36], 6 days East, to Ocean [aj37], 6 days South, to Ocean [ak36], 6 days West, to Ocean [aj35], 6 days


Supreme Court order on Sabari law to prove tough
A separate authority will mean the revenue from Sabarimala could be used only for development and administration of the Lord Ayyappa temple.
by DECCAN CHRONICLE.Kochi: The Supreme Court direction to Kerala to frame an exclusive law for administration of Sabarimala temple has caught the state government in a catch 22 situation with regard to the Travancore Devaswom Board (TDB).
The constitution of an independent authority separately for the hill shrine on the lines of Guruvayur and Tirupati Tirumala Venkateswara temples will not only undermine the importance of TDB but also will affect very functioning of a majority of temples in the state. A separate authority will mean the revenue from Sabarimala could be used only for development and administration of the Lord Ayyappa temple.
“Sabarimala is the main revenue earning source of the TDB which is dependent on the funds to manage the affairs of a majority of other temples under it. Only 83 out of the total 1250 temples managed by the TDB have more annual revenue than the expenses incurred and the rest are “loss-making”. Out of it, just 18 comes under the high revenue-earning category,” sources said.


SCCEd
Home
Citizen Science
Infrastructure
Curriculum
About
Contact
Buildings
Energy
Food
Public Space
Trans-Com
Waste & San
Water
Citizen Science Data
Student education program overview
Student data collection of Sustainability and Neighborhood Wellbeing in the metro area


ORCIDClientImpl
public interface ORCIDClient
works
.| Modifier and Type | Method | Description |
|---|---|---|
PTCRISyncResult<org.um.dsi.gavea.orcid.model.funding.Funding> |
addFunding(org.um.dsi.gavea.orcid.model.funding.Funding funding) |
Adds a new funding entry to the ORCID profile and returns the assigned
put-code.
|
PTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work> |
addWork(org.um.dsi.gavea.orcid.model.work.Work work) |
Adds a new work to the ORCID profile and returns the assigned put-code.
|
java.util.List<PTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work>> |
addWorks(java.util.List<org.um.dsi.gavea.orcid.model.work.Work> works) |
Adds a list of new works to the ORCID profile.
|
PTCRISyncResult<org.um.dsi.gavea.orcid.model.funding.Funding> |
deleteFunding(java.math.BigInteger putcode) |
Deletes a funding entry from the ORCID profile.
|
PTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work> |
deleteWork(java.math.BigInteger putcode) |
Deletes a work from the ORCID profile.
|
org.um.dsi.gavea.orcid.model.activities.ActivitiesSummary |
getActivitiesSummary() |
Retrieves every activity summary from the ORCID profile.
|
java.lang.String |
getClientId() |
Returns the Member API client id that will commit the changes (i.e., the
works' source).
|
PTCRISyncResult<org.um.dsi.gavea.orcid.model.funding.Funding> |
getFunding(org.um.dsi.gavea.orcid.model.funding.FundingSummary summary) |
Retrieves a complete funding entry from the ORCID profile (as opposed to
only its summary).
|
org.um.dsi.gavea.orcid.model.activities.Fundings |
getFundingsSummary() |
Retrieves every funding summary from the ORCID profile.
|
java.lang.String |
getUserId() |
Returns the user ORCID to whose profiles the changes will be commited.
|
PTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work> |
getWork(org.um.dsi.gavea.orcid.model.work.WorkSummary summary) |
Retrieves a complete work from the ORCID profile (as opposed to only its
summary).
|
java.util.Map<java.math.BigInteger,PTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work>> |
getWorks(java.util.List<org.um.dsi.gavea.orcid.model.work.WorkSummary> summaries) |
Retrieves a list of complete work from the ORCID profile (as opposed to
only their summaries).
|
org.um.dsi.gavea.orcid.model.activities.Works |
getWorksSummary() |
Retrieves every work summary from the ORCID profile.
|
int |
threads() |
The number of worker threads that will be used to communicate with the
ORCID API.
|
PTCRISyncResult<org.um.dsi.gavea.orcid.model.funding.Funding> |
updateFunding(java.math.BigInteger putcode,
org.um.dsi.gavea.orcid.model.funding.Funding funding) |
Updates a funding entry in the ORCID profile.
|
PTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work> |
updateWork(java.math.BigInteger putcode,
org.um.dsi.gavea.orcid.model.work.Work work) |
Updates a work in the ORCID profile.
|
java.lang.String getClientId()
java.lang.String getUserId()
org.um.dsi.gavea.orcid.model.activities.ActivitiesSummary getActivitiesSummary() throws org.um.dsi.gavea.orcid.client.exception.OrcidClientException
org.um.dsi.gavea.orcid.client.exception.OrcidClientException
- if the communication with ORCID failsorg.um.dsi.gavea.orcid.model.activities.Works getWorksSummary() throws org.um.dsi.gavea.orcid.client.exception.OrcidClientException
org.um.dsi.gavea.orcid.client.exception.OrcidClientException
- if the communication with ORCID failsorg.um.dsi.gavea.orcid.model.activities.Fundings getFundingsSummary() throws org.um.dsi.gavea.orcid.client.exception.OrcidClientException
org.um.dsi.gavea.orcid.client.exception.OrcidClientException
- if the communication with ORCID failsPTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work> getWork(org.um.dsi.gavea.orcid.model.work.WorkSummary summary)
PTCRISyncResult
.summary
- the summary of the work to be retrievedPTCRISyncResult<org.um.dsi.gavea.orcid.model.funding.Funding> getFunding(org.um.dsi.gavea.orcid.model.funding.FundingSummary summary)
PTCRISyncResult
.summary
- the summary of the funding entry to be retrievedjava.util.Map<java.math.BigInteger,PTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work>> getWorks(java.util.List<org.um.dsi.gavea.orcid.model.work.WorkSummary> summaries)
PTCRISyncResult
. This should generate a single API call
internally.summaries
- the summaries of the works to be retrievedPTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work> addWork(org.um.dsi.gavea.orcid.model.work.Work work)
PTCRISyncResult
.work
- the work to be added to the ORCID profilePTCRISyncResult<org.um.dsi.gavea.orcid.model.funding.Funding> addFunding(org.um.dsi.gavea.orcid.model.funding.Funding funding)
PTCRISyncResult
.funding
- the funding entry to be added to the ORCID profilejava.util.List<PTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work>> addWorks(java.util.List<org.um.dsi.gavea.orcid.model.work.Work> works)
PTCRISyncResult
. This should generate a single API call
internally.works
- the works to be added to the ORCID profilePTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work> deleteWork(java.math.BigInteger putcode)
PTCRISyncResult
.putcode
- the put-code of the work to be deletedPTCRISyncResult<org.um.dsi.gavea.orcid.model.funding.Funding> deleteFunding(java.math.BigInteger putcode)
PTCRISyncResult
.putcode
- the put-code of the funding entry to be deletedPTCRISyncResult<org.um.dsi.gavea.orcid.model.work.Work> updateWork(java.math.BigInteger putcode, org.um.dsi.gavea.orcid.model.work.Work work)
PTCRISyncResult
.putcode
- the put-code of the work to be updatedwork
- the new state of the workPTCRISyncResult<org.um.dsi.gavea.orcid.model.funding.Funding> updateFunding(java.math.BigInteger putcode, org.um.dsi.gavea.orcid.model.funding.Funding funding)
PTCRISyncResult
.putcode
- the put-code of the funding entry to be updatedfunding
- the new state of the funding entryint threads()


While TensorFlow models are typically defined and trained using R or Python code, it is possible to deploy TensorFlow models in a wide variety of environments without any runtime dependency on R or Python:
TensorFlow Serving is an open-source software library for serving TensorFlow models using a gRPC interface.
CloudML is a managed cloud service that serves TensorFlow models using a REST interface.
RStudio Connect provides support for serving models using the same REST API as CloudML, but on a server within your own organization.
TensorFlow models can also be deployed to mobile and embedded devices including iOS and Android mobile phones and Raspberry Pi computers.
The R interface to TensorFlow includes a variety of tools designed to make exporting and serving TensorFlow models straightforward. The basic process for deploying TensorFlow models from R is as follows:
Train a model using the keras, tfestimators, or tensorflow R packages.
Call the export_savedmodel()
function on your trained model write it to disk as a TensorFlow SavedModel.
Use the serve_savedmodel()
and predict_savedmodel()
functions from the tfdeploy package to run a local test server that supports the same REST API as CloudML and RStudio Connect.
Deploy your model using TensorFlow Serving, CloudML, or RStudio Connect.
Begin by installing the tfdeploy package from GitHub as follows:
devtools::install_github("rstudio/tfdeploy")
Next we’ll walk through an end-to-end example using a model trained with keras package. After that we’ll describe in more depth the specific requirements and various options associated with exporting models. Finally, we’ll cover the various deployment options and provide links to additional documentation.
We’ll use a Keras model that recognizes handwritten digits from the MNIST dataset as an example. MNIST consists of 28 x 28 grayscale images of handwritten digits like these:
The dataset also includes labels for each image, telling us which digit it is. For example, the labels for the above images are 5, 0, 4, and 1.
Here’s the complete source code for the model:
library(keras)
# load data
c(c(x_train, y_train), c(x_test, y_test)) %<-% dataset_mnist()
# reshape and rescale
x_train <- array_reshape(x_train, dim = c(nrow(x_train), 784)) / 255
x_test <- array_reshape(x_test, dim = c(nrow(x_test), 784)) / 255
# one-hot encode response
y_train <- to_categorical(y_train, 10)
y_test <- to_categorical(y_test, 10)
# define and compile model
model <- keras_model_sequential()
model %>%
layer_dense(units = 256, activation = 'relu', input_shape = c(784),
name = "image") %>%
layer_dense(units = 128, activation = 'relu') %>%
layer_dense(units = 10, activation = 'softmax',
name = "prediction") %>%
compile(
loss = 'categorical_crossentropy',
optimizer = optimizer_rmsprop(),
metrics = c('accuracy')
)
# train model
history <- model %>% fit(
x_train, y_train,
epochs = 30, batch_size = 128,
validation_split = 0.2
)
Note that we have given the first and last layers names (“image” and “prediction” respectively). You should always provide sensible names for your input and output layers when creating Keras models which you plan on deploying.
As a baseline, let’s predict the digits using the in-memory Keras model for the first 10 images within the test set (next, we’ll see how we can generate predictions from an exported model which requires no references to the original code used to train the model):
preds <- predict(model, x_test[1:10,])
round(preds, 4)
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,] 0.0160 0.0544 0.0420 0.1529 0.1236 0.4482 0.0252 0.0356 0.0579 0.0443
[2,] 0.0164 0.0568 0.0447 0.1324 0.0926 0.5013 0.0301 0.0252 0.0587 0.0419
[3,] 0.0135 0.0494 0.0366 0.1349 0.0893 0.5265 0.0253 0.0247 0.0557 0.0440
[4,] 0.0196 0.0641 0.0480 0.1545 0.1416 0.4003 0.0308 0.0411 0.0583 0.0419
[5,] 0.0163 0.0612 0.0474 0.1376 0.1595 0.4141 0.0272 0.0392 0.0549 0.0426
[6,] 0.0136 0.0467 0.0365 0.1349 0.0849 0.5299 0.0253 0.0237 0.0585 0.0460
[7,] 0.0136 0.0562 0.0400 0.1391 0.1513 0.4449 0.0254 0.0322 0.0545 0.0426
[8,] 0.0145 0.0575 0.0440 0.1382 0.1568 0.4320 0.0254 0.0312 0.0521 0.0483
[9,] 0.0157 0.0541 0.0391 0.1347 0.1064 0.4903 0.0305 0.0275 0.0610 0.0407
[10,] 0.0159 0.0558 0.0439 0.1383 0.1706 0.4041 0.0261 0.0365 0.0611 0.0476
The values displayed represent the probabilties that each image is the respctive digit (so the prediction for a given image is the column with the largest probability)
It’s straightfoward to generate predictions when we have access to the original R code used to train the model, but what if we want to deploy the model in an environment where R isn’t available? The next sections cover doing this with the tfdeploy package.
After training, the next step is to export the model as a TensorFlow SavedModel using the export_savedmodel()
function:
library(tfdeploy)
export_savedmodel(model, "savedmodel")
This will create a “savedmodel” directory that contains a saved version of your MNIST model. You can view the graph of your model using TensorBoard with the view_savedmodel()
function:
view_savedmodel("savedmodel")
You can generate predictions from the exported model using the predict_savedmodel()
function. The predict_savedmodel()
requires that we pass a list()
of instances to generate predictions for (as distinct from the predict()
function above which could take an N-dimensional array where the first dimension represents the instances). So we first transform the 10x784 matrix of test images into a 10 element list of length 784 vectors:
test_images <- x_test[1:10,]
test_images <- lapply(1:nrow(test_images), function(i) test_images[i,])
Now we can call predict_savedmodel()
, passing the test images (as a list) and specifying the directory where the model was saved:
preds <- predict_savedmodel(
test_images,
"savedmodel",
type = "export"
)
preds
$predictions
prediction
1 0.0160, 0.0544, 0.0420, 0.1529, 0.1236, 0.4482, 0.0252, 0.0356, 0.0579, 0.0443
2 0.0164, 0.0568, 0.0447, 0.1324, 0.0926, 0.5013, 0.0301, 0.0252, 0.0587, 0.0419
3 0.0135, 0.0494, 0.0366, 0.1349, 0.0893, 0.5265, 0.0253, 0.0247, 0.0557, 0.0440
4 0.0196, 0.0641, 0.0480, 0.1545, 0.1416, 0.4003, 0.0308, 0.0411, 0.0583, 0.0419
5 0.0163, 0.0612, 0.0474, 0.1376, 0.1595, 0.4141, 0.0272, 0.0392, 0.0549, 0.0426
6 0.0136, 0.0467, 0.0365, 0.1349, 0.0849, 0.5299, 0.0253, 0.0237, 0.0585, 0.0460
7 0.0136, 0.0562, 0.0400, 0.1391, 0.1513, 0.4449, 0.0254, 0.0322, 0.0545, 0.0426
8 0.0145, 0.0575, 0.0440, 0.1382, 0.1568, 0.4320, 0.0254, 0.0312, 0.0521, 0.0483
9 0.0157, 0.0541, 0.0391, 0.1347, 0.1064, 0.4903, 0.0305, 0.0275, 0.0610, 0.0407
10 0.0159, 0.0558, 0.0439, 0.1383, 0.1706, 0.4041, 0.0261, 0.0365, 0.0611, 0.0476
Note that this function can be called without defining or loading the Keras model (in fact no reference to the code originally used to build and train the model is required). As we will see below, we can even generate predictions from other languages using an HTTP/REST interface to the model!
The tfdeploy package includes a local server which you can use to test the HTTP/REST interace to your model before deployment. To serve a model locally, use the serve_savedmodel()
function:
serve_savedmodel("savedmodel")
Starting server under http://<IP_ADDRESS>:8089 with the following API entry points:
http://<IP_ADDRESS>:8089/api/serving_default/predict/
You can now call the model from another R session using the predict_savedmodel()
function. Here we’ll actually pass a real image from the MNIST test set to predict_savedmodel()
(previously we just passed all zeros):
library(keras)
# prepare list of test images
c(c(x_train, y_train), c(x_test, y_test)) %<-% dataset_mnist()
x_test <- array_reshape(x_test, dim = c(nrow(x_test), 784)) / 255
test_images <- x_test[1:10,]
test_images <- lapply(1:nrow(test_images), function(i) test_images[i,])
# invoke webapi to generate predictions
library(tfdeploy)
preds <- predict_savedmodel(
test_images,
"http://localhost:8089/api/serving_default/predict",
type = "webapi"
)
You could also call the model from another langague entirely since the interface is just HTTP and REST. For example, if the following JSON is submitted to the endpoint as a request body it will return predictions:
{
"instances": [
{
"image_input": [0,0,0,...,0,0]
},
{
"image_input": [0,0,0,...,0,0]
},
{
"image_input": [0,0,0,...,0,0]
},
// ...more instances
]
}
Additional details on the JSON schema used for the REST interface is provided in the Model Deployment section below.
Once you have tested your model locally you can deploy it to a server. There are a number of available options for this including TensorFlow Serving, CloudML, and RStudio Connect. For example, if we wanted to deploy our saved model to CloudML we could do this:
library(cloudml)
cloudml_deploy("savedmodel", name = "keras_mnist", version = "keras_mnist_1")
Now that we’ve walked through a simple end-to-end example, we’ll describe the processes of Model Export and Model Deployment in more detail.
TensorFlow SavedModel defines a language-neutral format to save machine-learned models that is recoverable and hermetic. It enables higher-level systems and tools to produce, consume and transform TensorFlow models.
The export_savedmodel()
function creates a SavedModel from a model trained using the keras, tfestimators, or tensorflow R packages. There are subtle differences in how this works in practice depending on the package you are using.
The Keras Example above includes complete example code for creating and using SavedModel instances from Keras so we won’t repeat all of those details here.
To export a TensorFlow SavedModel from a Keras model, simply call the export_savedmodel()
function on any Keras model:
export_savedmodel(model, "savedmodel")
Keras learning phase set to 0 for export (restart R session before doing additional training)
Note the message that is printed indicates that a side effect of exporting the model was setting the Keras “learning phase” (whether it is training or doing inference) to 0. This is necessary to export Keras models to TensorFlow and carries the implication that you shouldn’t do additional training within your R session after calling export_savedmodel()
(because Keras will be hard-coded to be in inference mode, which means it won’t update weights as data flows through it’s graph).
Exporting a TensorFlow SavedModel from a TF Estimators model works exactly the same way, simply call export_savedmodel()
on the estimator. Here is a complete example:
library(tfestimators)
mtcars_input_fn <- function(data, num_epochs = 1) {
input_fn(data,
features = c("disp", "cyl"),
response = "mpg",
batch_size = 32,
num_epochs = num_epochs)
}
cols <- feature_columns(column_numeric("disp"), column_numeric("cyl"))
model <- linear_regressor(feature_columns = cols)
indices <- sample(1:nrow(mtcars), size = 0.80 * nrow(mtcars))
train <- mtcars[indices, ]
test <- mtcars[-indices, ]
model %>% train(mtcars_input_fn(train, num_epochs = 10))
export_savedmodel(model, "savedmodel")
We can now generate predictions from the model as follows:
# transform data frame records into list of named lists
test_records <- mtcars[1:5, c("disp", "cyl")]
test_records <- lapply(1:nrow(test_records), function(i) as.list(test_records[i,]))
# generate predictions
library(tfdeploy)
preds <- predict_savedmodel(
test_records,
"savedmodel",
type = "export",
signature_name = "predict"
)
preds
$predictions
predictions
1 13.3829
2 13.3829
3 9.1437
4 20.5719
5 28.4791
The tensorflow package provides a lower-level interface to the TensorFlow API. You can also use the export_savedmodel()
function to export models created with this API, however you need to provide some additional parmaeters indicating which tensors represent the inputs and outputs for your model.
For example, here’s an MNIST model using the core TensorFlow API along with the requisite call to export_savedmodel()
:
library(tensorflow)
sess <- tf$Session()
datasets <- tf$contrib$learn$datasets
mnist <- datasets$mnist$read_data_sets("MNIST-data", one_hot = TRUE)
x <- tf$placeholder(tf$float32, shape(NULL, 784L))
W <- tf$Variable(tf$zeros(shape(784L, 10L)))
b <- tf$Variable(tf$zeros(shape(10L)))
y <- tf$nn$softmax(tf$matmul(x, W) + b)
y_ <- tf$placeholder(tf$float32, shape(NULL, 10L))
cross_entropy <- tf$reduce_mean(
-tf$reduce_sum(y_ * tf$log(y), reduction_indices=1L)
)
optimizer <- tf$train$GradientDescentOptimizer(0.5)
train_step <- optimizer$minimize(cross_entropy)
init <- tf$global_variables_initializer()
sess$run(init)
for (i in 1:1000) {
batches <- mnist$train$next_batch(100L)
batch_xs <- batches[[1]]
batch_ys <- batches[[2]]
sess$run(train_step,
feed_dict = dict(x = batch_xs, y_ = batch_ys))
}
export_savedmodel(
sess,
"savedmodel",
inputs = list(images = x),
outputs = list(scores = y))
You can then generate predictions as follows:
# prepare list of test images
test_images <- mnist$test$next_batch(10L)[[1]]
test_images <- lapply(1:nrow(test_images), function(i) test_images[i,])
# generate predictions
library(tfdeploy)
preds <- predict_savedmodel(
test_images,
"savedmodel",
type = "export"
)
There are a variety of ways to deploy a TensorFlow SavedModel, each of which are described below. Of the 4 methods described, 3 of them (the local server, CloudML, and RStudio Connect) all share the same REST interface, which is described in detail here: https://cloud.google.com/ml-engine/docs/v1/predict-request.
The first place you are likely to “deploy” a SavedModel is on your local system, for the purpose of testing and refining the prediction API. The serve_savedmodel()
function runs a local server that serves your model:
serve_savedmodel("savedmodel")
Starting server under http://<IP_ADDRESS>:8089 with the following API entry points:
http://<IP_ADDRESS>:8089/api/serving_default/predict/
The REST API used by the local server is based on the CloudML predict request API.
If you navigate to http://localhost:8089 you’ll see a web page that describes the REST interace to your model:
You can request predictions remotely from any language or environment using this REST API. You can also call the predict_savedmodel()
function from R:
predict_savedmodel(
input_data,
"http://localhost:8089/api/serving_default/predict",
type = "webapi"
)
You can deploy TensorFlow SavedModels to Google’s CloudML service using functions from the cloudml package. For example:
library(cloudml)
cloudml_deploy("savedmodel", name = "keras_mnist")
You can generate predictions using the cloudml_predict()
function:
cloudml_predict(test_images, name = "keras_mnist")
See the Deploying Models article on the CloudML package website for additional details.
RStudio Connect is a server publishing platform for applications, reports, and APIs created with R.
An upcoming version of RStudio Connect will include support for hosting TensorFlow SavedModels, using the same REST interface as is supported by the local server and CloudML.
TensorFlow Serving is an open-source library and server implementation that allows you to serve TensorFlow SavedModels using a gRPC interface.
Once you have exported a TensorFlow model using export_savedmodel()
it’s straightforward to deploy it using TensorFlow Serving. See the documentation at https://www.tensorflow.org/serving for additional details.


The island of Sao Sebastiao is about 45 NM north of Santos. It lies just 2 miles off the coast, opposite the town of the same name.
Position 23°50'S, 45°22'W.
Read Brazil Formalities for full details on clearing into and out of Brazil.
All the necessary authorities are on the waterfront in the town of San Sebastiao.
The only possible mooring on the mainland is in the small basin behind the ferry termnal. Here you berth among the fishing boats. There are no anchorages this side of the channel.
On the island of Sao Sebastiao there are several options of swinging moorings on the west coast, anchoring in front of the village, or in various anchorages around the north and east coasts.
There are several yacht clubs here and most offer a few days free mooring to visitors.
For repairs, supplies, chandlery or banking etc. it is better to moor on the island and take the ferry to the mainland.
Last updated January 2010.


StreamInterface
Defines Generic PHP stream wrapper interface.
Methods
Support for fopen(), filegetcontents(), fileputcontents() etc.
Support for fclose().
Support for flock().
Support for touch(), chmod(), chown(), chgrp().
Support for fread(), filegetcontents() etc.
Support for fwrite(), fileputcontents() etc.
Support for feof().
Support for fseek().
Support for fflush().
Support for ftell().
Support for fstat().
Support for unlink().
Support for rename().
Support for mkdir().
Support for rmdir().
Support for stat().
Support for opendir().
Support for readdir().
Support for rewinddir().
Support for closedir().
Details
at line 26
bool
stream_open(
string $uri,
string $mode,
int $options,
string $opened_url)
Support for fopen(), filegetcontents(), fileputcontents() etc.
at line 34
bool
stream_close()
Support for fclose().
at line 50
bool
stream_lock($operation)
Support for flock().
at line 82
bool
stream_metadata($path, $option, $value)
Support for touch(), chmod(), chown(), chgrp().
at line 93
string|bool
stream_read($count)
Support for fread(), filegetcontents() etc.
at line 104
int
stream_write($data)
Support for fwrite(), fileputcontents() etc.
at line 112
bool
stream_eof()
Support for feof().
at line 125
bool
stream_seek($offset, $whence)
Support for fseek().
at line 133
bool
stream_flush()
Support for fflush().
at line 141
int
stream_tell()
Support for ftell().
at line 149
array
stream_stat()
Support for fstat().
at line 161
TRUE
unlink($uri)
Support for unlink().
at line 174
bool
rename($from_uri, $to_uri)
Support for rename().
at line 189
bool
mkdir($uri, $mode, $options)
Support for mkdir().
at line 204
TRUE
rmdir($uri, $options)
Support for rmdir().
at line 217
array
url_stat($uri, $flags)
Support for stat().
at line 230
bool
dir_opendir($uri, $options)
Support for opendir().
at line 238
string
dir_readdir()
Support for readdir().
at line 246
bool
dir_rewinddir()
Support for rewinddir().
at line 254
bool
dir_closedir()
Support for closedir().


LLVM 2.6 Release Notes
- Introduction
- Sub-project Status Update
- External Projects Using LLVM 2.6
- What's New in LLVM 2.6?
- Installation Instructions
- Portability and Supported Platforms
- Known Problems
- Additional Information
This document contains the release notes for the LLVM Compiler
Infrastructure, release 2.6. Here we describe the status of LLVM, including
major improvements from the previous release and significant known problems.
All LLVM releases may be downloaded from the LLVM releases web site.
For more information about LLVM, including information about the latest
release, please check out the main LLVM
web site. If you have questions or comments, the LLVM Developer's Mailing
List is a good place to send them.
Note that if you are reading this file from a Subversion checkout or the
main LLVM web page, this document applies to the next release, not the
current one. To see the release notes for a specific release, please see the
releases page.
The LLVM 2.6 distribution currently consists of code from the core LLVM
repository —which roughly includes the LLVM optimizers, code generators
and supporting tools — and the llvm-gcc repository. In addition to this
code, the LLVM Project includes other sub-projects that are in development. The
two which are the most actively developed are the Clang
Project and the VMKit Project.
The Clang project is an effort to build
a set of new 'LLVM native' front-end technologies for the LLVM optimizer and
code generator. While Clang is not included in the LLVM 2.6 release, it is
continuing to make major strides forward in all areas. Its C and Objective-C
parsing and code generation support is now very solid. For example, it is
capable of successfully building many real-world applications for X86-32
and X86-64,
including the FreeBSD
kernel and gcc 4.2. C++ is also
making incredible progress,
and work on templates has recently started. If you are
interested in fast compiles and good diagnostics, we encourage you to try it out
by building from mainline
and reporting any issues you hit to the Clang front-end mailing
list.
In the LLVM 2.6 time-frame, the Clang team has made many improvements:
- Something wonderful!
- AuroraUX / FreeBSD & OpenBSD Toolchain support.
- Many many bugs are fixed and many features have been added.
Previously announced in the 2.4 LLVM release, the Clang project also
includes an early stage static source code analysis tool for automatically finding bugs
in C and Objective-C programs. The tool performs a growing set of checks to find
bugs that occur on a specific path within a program.
In the LLVM 2.6 time-frame there have been many significant improvements to
XYZ.
The set of checks performed by the static analyzer continues to expand, and
future plans for the tool include full source-level inter-procedural analysis
and deeper checks such as buffer overrun detection. There are many opportunities
to extend and enhance the static analyzer, and anyone interested in working on
this project is encouraged to get involved!
The VMKit project is an implementation of
a JVM and a CLI Virtual Machines (Microsoft .NET is an
implementation of the CLI) using the Just-In-Time compiler of LLVM.
Following LLVM 2.6, VMKit has its XYZ release that you can find on its
webpage. The release includes
bug fixes, cleanup and new features. The major changes are:
Pure
is an algebraic/functional programming language based on term rewriting.
Programs are collections of equations which are used to evaluate expressions in
a symbolic fashion. Pure offers dynamic typing, eager and lazy evaluation,
lexical closures, a hygienic macro system (also based on term rewriting),
built-in list and matrix support (including list and matrix comprehensions) and
an easy-to-use C interface. The interpreter uses LLVM as a backend to
JIT-compile Pure programs to fast native code.
In addition to the usual algebraic data structures, Pure also has
MATLAB-style matrices in order to support numeric computations and signal
processing in an efficient way. Pure is mainly aimed at mathematical
applications right now, but it has been designed as a general purpose language.
The dynamic interpreter environment and the C interface make it possible to use
it as a kind of functional scripting language for many application areas.
LDC is an implementation of
the D Programming Language using the LLVM optimizer and code generator.
The LDC project works great with the LLVM 2.6 release. General improvements in
this
cycle have included new inline asm constraint handling, better debug info
support, general bugfixes, and better x86-64 support. This has allowed
some major improvements in LDC, getting us much closer to being as
fully featured as the original DMD compiler from DigitalMars.
Roadsend PHP (rphp) is an open
source implementation of the PHP programming
language that uses LLVM for its optimizer, JIT, and static compiler. This is a
reimplementation of an earlier project that is now based on LLVM.
Unladen Swallow is a
branch of Python intended to be fully
compatible and significantly faster. It uses LLVM's optimization passes and JIT
compiler.
Rubinius is a new virtual
machine for Ruby. It leverages LLVM to dynamically compile Ruby code down to
machine code using LLVM's JIT.
This release includes a huge number of bug fixes, performance tweaks, and
minor improvements. Some of the major improvements and new features are listed
in this section.
LLVM 2.6 includes several major new capabilities:
- Something wonderful!
- LLVM 2.6 includes a brand new experimental LLVM bindings to the Ada2005 programming language.
LLVM fully supports the llvm-gcc 4.2 front-end, which marries the GCC
front-ends and driver with the LLVM optimizer and code generator. It currently
includes support for the C, C++, Objective-C, Ada, and Fortran front-ends.
LLVM IR has several new features that are used by our existing front-ends and
can be useful if you are writing a front-end for LLVM:
In addition to a large array of bug fixes and minor performance tweaks, this
release includes a few major enhancements and additions to the optimizers:
We have put a significant amount of work into the code generator
infrastructure, which allows us to implement more aggressive algorithms and make
it run faster:
New features of the X86 target include:
New features of the PIC16 target include:
Things not yet supported:
- Floating point.
- Passing/returning aggregate types to and from functions.
- Variable arguments.
- Indirect function calls.
- Interrupts/programs.
- Debug info.
New features of the ARM target include:
- Preliminary support for processors, such as the Cortex-A8 and Cortex-A9,
that implement version v7-A of the ARM architecture. The ARM backend now
supports both the Thumb2 and Advanced SIMD (Neon) instruction sets. The
AAPCS-VFP "hard float" calling conventions are also supported with the
-float-abi=hard flag. These features are still somewhat experimental
and subject to change. The Neon intrinsics, in particular, may change in future
releases of LLVM.
If you're already an LLVM user or developer with out-of-tree changes based
on LLVM 2.5, this section lists some "gotchas" that you may run into upgrading
from the previous release.
In addition, many APIs have changed in this release. Some of the major LLVM
API changes are:
- LLVM's global uniquing tables for Types and Constants have
been privatized into members of an LLVMContext. A number of APIs
now take an LLVMContext as a parameter. To smooth the transition
for clients that will only ever use a single context, the new
getGlobalContext() API can be used to access a default global
context which can be passed in any and all cases where a context is
required.
- The getABITypeSize methods are now called getAllocSize.
- The Add, Sub, and Mul operators are no longer
overloaded for floating-point types. Floating-point addition, subtraction,
and multiplication are now represented with new operators FAdd,
FSub, and FMul. In the IRBuilder API,
CreateAdd, CreateSub, CreateMul, and
CreateNeg should only be used for integer arithmetic now;
CreateFAdd, CreateFSub, CreateFMul, and
CreateFNeg should now be used for floating-point arithmetic.
- The DynamicLibrary class can no longer be constructed, its functionality has
moved to static member functions.
- raw_fd_ostream's constructor for opening a given filename now
takes an extra Force argument. If Force is set to
false, an error will be reported if a file with the given name
already exists. If Force is set to true, the file will
be silently truncated (which is the behavior before this flag was
added).
- SCEVHandle no longer exists, because reference counting is no
longer done for SCEV* objects, instead const SCEV* should be
used.
- Many APIs, notably llvm::Value, now use the StringRef
and Twine classes instead of passing const char*
or std::string, as described in
the Programmer's Manual. Most
clients should be unaffected by this transition, unless they are used to Value::getName() returning a string. Here are some tips on updating to 2.6:
- getNameStr() is still available, and matches the old
behavior. Replacing getName() calls with this is an safe option,
although more efficient alternatives are now possible.
- If you were just relying on getName() being able to be sent to
a std::ostream, consider migrating
to llvm::raw_ostream.
- If you were using getName().c_str() to get a const
char* pointer to the name, you can use getName().data().
Note that this string (as before), may not be the entire name if the
name containts embedded null characters.
- If you were using operator plus on the result of getName() and
treating the result as an std::string, you can either
uses Twine::str to get the result as an std::string, or
could move to a Twine based design.
- isName() should be replaced with comparison
against getName() (this is now efficient).
- The registration interfaces for backend Targets has changed (what was
previously TargetMachineRegistry). For backend authors, see the Writing An LLVM Backend guide. For clients, the notable API changes are:
- TargetMachineRegistry has been renamed
to TargetRegistry.
- Clients should move to using the TargetRegistry::lookupTarget()
function to find targets.
- llvm-dis now fails if output file exists, instead of dumping to stdout.
FIXME: describe any other tool changes due to the raw_fd_ostream change. FIXME:
This is not an API change, maybe there should be a tool changes section?
- temporarely due to Context API change passes should call doInitialization()
method of the pass they inherit from, otherwise Context is NULL.
FIXME: remove this entry when this is no longer needed.
-
LLVM is known to work on the following platforms:
- Intel and AMD machines (IA32, X86-64, AMD64, EMT-64) running Red Hat
Linux, Fedora Core, FreeBSD and AuroraUX (and probably other unix-like systems).
- PowerPC and X86-based Mac OS X systems, running 10.3 and above in 32-bit
and 64-bit modes.
- Intel and AMD machines running on Win32 using MinGW libraries (native).
- Intel and AMD machines running on Win32 with the Cygwin libraries (limited
support is available for native builds with Visual C++).
- Sun UltraSPARC workstations running Solaris 10.
- Alpha-based machines running Debian GNU/Linux.
The core LLVM infrastructure uses GNU autoconf to adapt itself
to the machine and operating system on which it is built. However, minor
porting may be required to get LLVM to work on new platforms. We welcome your
portability patches and reports of successful builds or error messages.
This section contains significant known problems with the LLVM system,
listed by component. If you run into a problem, please check the LLVM bug database and submit a bug if
there isn't already one.
- LLVM will not correctly compile on Solaris and/or OpenSolaris
using the stock GCC 3.x.x series 'out the box',
See: Broken versions of GCC and other tools.
However, A Modern GCC Build
for x86/x64 has been made available from the third party AuroraUX Project
that has been meticulously tested for bootstrapping LLVM & Clang.
The following components of this LLVM release are either untested, known to
be broken or unreliable, or are in early development. These components should
not be relied on, and bugs should not be filed against them, but they may be
useful to some people. In particular, if you would like to work on one of these
components, please contact us on the LLVMdev list.
- The MSIL, Alpha, SPU, MIPS, and PIC16 backends are experimental.
- The llc "-filetype=asm" (the default) is the only
supported value for this option.
- The X86 backend does not yet support
all inline assembly that uses the X86
floating point stack. It supports the 'f' and 't' constraints, but not
'u'.
- The X86 backend generates inefficient floating point code when configured
to generate code for systems that don't have SSE2.
- Win64 code generation wasn't widely tested. Everything should work, but we
expect small issues to happen. Also, llvm-gcc cannot build the mingw64
runtime currently due
to several
bugs and due to lack of support for
the
'u' inline assembly constraint and for X87 floating point inline assembly.
- The X86-64 backend does not yet support the LLVM IR instruction
va_arg. Currently, the llvm-gcc and front-ends support variadic
argument constructs on X86-64 by lowering them manually.
- The Linux PPC32/ABI support needs testing for the interpreter and static
compilation, and lacks support for debug information.
- Support for the Advanced SIMD (Neon) instruction set is still incomplete
and not well tested. Some features may not work at all, and the code quality
may be poor in some cases.
- Thumb mode works only on ARMv6 or higher processors. On sub-ARMv6
processors, thumb programs can crash or produce wrong
results (PR1388).
- Compilation for ARM Linux OABI (old ABI) is supported but not fully tested.
- There is a bug in QEMU-ARM (<= 0.9.0) which causes it to incorrectly
execute
programs compiled with LLVM. Please use more recent versions of QEMU.
- The SPARC backend only supports the 32-bit SPARC ABI (-m32); it does not
support the 64-bit SPARC ABI (-m64).
- The O32 ABI is not fully supported.
- 64-bit MIPS targets are not supported yet.
- On 21164s, some rare FP arithmetic sequences which may trap do not have the
appropriate nops inserted to ensure restartability.
llvm-gcc does not currently support Link-Time
Optimization on most platforms "out-of-the-box". Please inquire on the
LLVMdev mailing list if you are interested.
The only major language feature of GCC not supported by llvm-gcc is
the __builtin_apply family of builtins. However, some extensions
are only supported on some targets. For example, trampolines are only
supported on some targets (these are used when you take the address of a
nested function).
If you run into GCC extensions which are not supported, please let us know.
The C++ front-end is considered to be fully
tested and works for a number of non-trivial programs, including LLVM
itself, Qt, Mozilla, etc.
- Exception handling works well on the X86 and PowerPC targets. Currently
only Linux and Darwin targets are supported (both 32 and 64 bit).
- Fortran support generally works, but there are still several unresolved bugs
in Bugzilla. Please see the tools/gfortran component for details.
The llvm-gcc 4.2 Ada compiler works fairly well; however, this is not a mature
technology, and problems should be expected.
- The Ada front-end currently only builds on X86-32. This is mainly due
to lack of trampoline support (pointers to nested functions) on other platforms.
However, it also fails to build on X86-64
which does support trampolines.
- The Ada front-end fails to bootstrap.
This is due to lack of LLVM support for setjmp/longjmp style
exception handling, which is used internally by the compiler.
Workaround: configure with --disable-bootstrap.
- The c380004, c393010
and cxg2021 ACATS tests fail
(c380004 also fails with gcc-4.2 mainline).
If the compiler is built with checks disabled then c393010
causes the compiler to go into an infinite loop, using up all system memory.
- Some GCC specific Ada tests continue to crash the compiler.
- The -E binder option (exception backtraces)
does not work and will result in programs
crashing if an exception is raised. Workaround: do not use -E.
- Only discrete types are allowed to start
or finish at a non-byte offset in a record. Workaround: do not pack records
or use representation clauses that result in a field of a non-discrete type
starting or finishing in the middle of a byte.
- The lli interpreter considers
'main' as generated by the Ada binder to be invalid.
Workaround: hand edit the file to use pointers for argv and
envp rather than integers.
- The -fstack-check option is
ignored.
A wide variety of additional information is available on the LLVM web page, in particular in the documentation section. The web page also
contains versions of the API documentation which is up-to-date with the
Subversion version of the source code.
You can access versions of these documents specific to this release by going
into the "llvm/doc/" directory in the LLVM tree.
If you have any questions or comments about LLVM, please feel free to contact
us via the mailing
lists.
LLVM Compiler Infrastructure
Last modified: $Date: 2009-08-21 19:17:22 -0700 (Fri, 21 Aug 2009) $


OpenProcessing
Discover
Learn
Teach
Create a Sketch
Join the creative coders on openProcessing
name
email
password
Join


ORLANDO A film review by James Berardinelli Copyright 1993 James Berardinelli
Rating: 7.9 out of 10 (B, **1/2 out of ****)
Date Released: 6/25/93 Running Length: 1:33 Rated: PG-13 (Brief nudity)
Starring: Tilda Swinton, Charlotte Valandrey, Lothaire Bluteau, Quentin Crisp, Billy Zane Director: Sally Potter Producer: Christopher Sheppard Screenplay: Sally Potter from the novel by Virginia Woolf Music: David Motion and Sally Potter Released by Sony Pictures Classics
The year is 1600 and the country is England. Orlando (Tilda Swinton) is a young nobleman who has found favor with Queen Elizabeth I (Quentin Crisp). As a result of his relationship as the "son" of her old age, Orlando is granted the deed to a sizable piece of property. Ten years later, following the death of his father, Orlando falls in love with a beautiful Russian princess (Charlotte Valandrey). After that relationship ends in tragedy, and following a brief-but-disastrous flirtation with poetry, Orlando becomes an ambassador to central Asia. It is now the 18th century and Orlando has lived more than one-hundred years without showing a day's aging. But the most remarkable event of his life--his sudden and unexpected transformation into a woman--is yet to come.
ORLANDO is a movie thin on story but thick on elegance and style. Characters and settings, as well as a brief-but-lavish tour through 400 years of history, take precedence over plot. Even on its own terms, the storyline of this film is weak and riddled with contrivances, questions, and problems. Writer Sally Potter, adapting from Virginia Woolf's novel, takes the approach that the narrative is essentially irrelevant. Its purpose is to allow explorations of Orlando as he/she develops over the years, and of the ever-changing attitudes of society.
Those that want a detailed examination of how a person copes with unusual longevity won't find it here. In fact, other than a throw-away line by Queen Elizabeth (in which she bestows land upon Orlando under the condition that he not grow old and wrinkled like her), there is no explanation given for why the title character neither ages nor dies. This is taken as a given; one of the many plot points glossed over.
Another thing that is more-or-less ignored is the mechanism by which Orlando changes sex. After a long sleep following a battle in which he refuses to kill, Orlando wakes up one morning as a woman. Her reaction is simple--"Same person ... different sex" and she evidences little or no surprise at the sudden and unexpected transformation.
Little issue is made of how other characters react to Orlando's femaleness. With the exception of Archduke Harry (John Wood), no one makes a big deal out of it, although the English courts remove Orlando's property since a woman cannot legally inherit land. As one man comments when the Victorian courts can't determine whether Orlando is dead or a woman, "They're pretty much the same thing."
One constant source of interest in ORLANDO is watching how English society and customs change over the centuries. After Orlando's transformation, it's fascinating to watch the size of her gown as it shrinks from its mammoth proportions of the 1700s to the more "natural" garb of the present day. This is only a subtle indication of how women come to be regarded more as people than property.
Other than Orlando, there is no character that is around for more than about 15 or 20 minutes. Billy Zane, who plays the American adventurer Shelmerdine, shares billing with lead actress Tilda Swinton, but is on-screen for only a handful of scenes. The same is true of all the other co-stars.
Swinton gives a masterful performance, displaying amazing range as both a man and a woman. Even though her decidedly-feminine appearance hurts the audience's ability to accept Orlando as a man, the manner in which Swinton speaks and acts during that part of the film are masculine. She is more believable after the transformation, but that's mainly because her looks now match her mannerisms.
Sharing the opposite-gender playing with Tilda Swinton is actor Quentin Crisp, who plays Queen Elizabeth I. There's no difficulty accepting Crisp as the wrinkled old queen. Perhaps this, in addition to other recent males-playing-females, indicate that, given the right physical appearance, it's easier to make up a man like a woman than the other way around.
Those that go to ORLANDO expecting a tightly-constructed plot will leave with deflated expectations. The power of this movie is far removed from any of the many contrivances centered around the emaciated storyline. See ORLANDO for its fabulous costumes, fascinating look at changing eras, and impressive performance by Tilda Swinton. Viewing this film for other reasons will almost certainly lead to a negative impression.
- James Berardinelli<EMAIL_ADDRESS>.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


QSignalMapper Class
The QSignalMapper class bundles signals from identifiable senders. More...
| Header: | #include <QSignalMapper> |
| qmake: | QT += core |
| Inherits: | QObject |
Public Functions
| QSignalMapper(QObject *parent = Q_NULLPTR) | |
| ~QSignalMapper() | |
| QObject * | mapping(int id) const |
| QObject * | mapping(const QString &id) const |
| QObject * | mapping(QWidget *widget) const |
| QObject * | mapping(QObject *object) const |
| void | removeMappings(QObject *sender) |
| void | setMapping(QObject *sender, int id) |
| void | setMapping(QObject *sender, const QString &text) |
| void | setMapping(QObject *sender, QWidget *widget) |
| void | setMapping(QObject *sender, QObject *object) |
- 32 public functions inherited from QObject
Public Slots
- 1 public slot inherited from QObject
Signals
| void | mapped(int i) |
| void | mapped(const QString &text) |
| void | mapped(QWidget *widget) |
| void | mapped(QObject *object) |
- 2 signals inherited from QObject
Additional Inherited Members
- 1 property inherited from QObject
- 11 static public members inherited from QObject
- 9 protected functions inherited from QObject
Detailed Description
The QSignalMapper class bundles signals from identifiable senders.
This class collects a set of parameterless signals, and re-emits them with integer, string or widget parameters corresponding to the object that sent the signal.
The class supports the mapping of particular strings or integers with particular objects using setMapping(). The objects' signals can then be connected to the map() slot which will emit the mapped() signal with the string or integer associated with the original signalling object. Mappings can be removed later using removeMappings().
Example: Suppose we want to create a custom widget that contains a group of buttons (like a tool palette). One approach is to connect each button's clicked()
signal to its own custom slot; but in this example we want to connect all the buttons to a single slot and parameterize the slot by the button that was clicked.
Here's the definition of a simple custom widget that has a single signal, clicked()
, which is emitted with the text of the button that was clicked:
class ButtonWidget : public QWidget { Q_OBJECT public: ButtonWidget(const QStringList &texts, QWidget *parent = 0); signals: void clicked(const QString &text); private: QSignalMapper *signalMapper; };
The only function that we need to implement is the constructor:
ButtonWidget::ButtonWidget(const QStringList &texts, QWidget *parent) : QWidget(parent) { signalMapper = new QSignalMapper(this); QGridLayout *gridLayout = new QGridLayout; for (int i = 0; i < texts.size(); ++i) { QPushButton *button = new QPushButton(texts[i]); connect(button, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(button, texts[i]); gridLayout->addWidget(button, i / 3, i % 3); } connect(signalMapper, SIGNAL(mapped(QString)), this, SIGNAL(clicked(QString))); setLayout(gridLayout); }
A list of texts is passed to the constructor. A signal mapper is constructed and for each text in the list a QPushButton is created. We connect each button's clicked()
signal to the signal mapper's map() slot, and create a mapping in the signal mapper from each button to the button's text. Finally we connect the signal mapper's mapped() signal to the custom widget's clicked()
signal. When the user clicks a button, the custom widget will emit a single clicked()
signal whose argument is the text of the button the user clicked.
See also QObject, QButtonGroup, and QActionGroup.
Member Function Documentation
QSignalMapper::QSignalMapper(QObject *parent = Q_NULLPTR)
Constructs a QSignalMapper with parent parent.
QSignalMapper::~QSignalMapper()
Destroys the QSignalMapper.
[slot]
void QSignalMapper::map()
This slot emits signals based on which object sends signals to it.
[slot]
void QSignalMapper::map(QObject *sender)
This slot emits signals based on the sender object.
[signal]
void QSignalMapper::mapped(int i)
This signal is emitted when map() is signalled from an object that has an integer mapping set. The object's mapped integer is passed in i.
Note: Signal mapped is overloaded in this class. To connect to this one using the function pointer syntax, you must specify the signal type in a static cast, as shown in this example:
connect(signalMapper, static_cast<void(QSignalMapper::*)(int)>(&QSignalMapper::mapped), [=](int i){ /* ... */ });
See also setMapping().
[signal]
void QSignalMapper::mapped(const QString &text)
This signal is emitted when map() is signalled from an object that has a string mapping set. The object's mapped string is passed in text.
Note: Signal mapped is overloaded in this class. To connect to this one using the function pointer syntax, you must specify the signal type in a static cast, as shown in this example:
connect(signalMapper, static_cast<void(QSignalMapper::*)(const QString &)>(&QSignalMapper::mapped), [=](const QString &text){ /* ... */ });
See also setMapping().
[signal]
void QSignalMapper::mapped(QWidget *widget)
This signal is emitted when map() is signalled from an object that has a widget mapping set. The object's mapped widget is passed in widget.
Note: Signal mapped is overloaded in this class. To connect to this one using the function pointer syntax, you must specify the signal type in a static cast, as shown in this example:
connect(signalMapper, static_cast<void(QSignalMapper::*)(QWidget *)>(&QSignalMapper::mapped), [=](QWidget *widget){ /* ... */ });
See also setMapping().
[signal]
void QSignalMapper::mapped(QObject *object)
This signal is emitted when map() is signalled from an object that has an object mapping set. The object provided by the map is passed in object.
Note: Signal mapped is overloaded in this class. To connect to this one using the function pointer syntax, you must specify the signal type in a static cast, as shown in this example:
connect(signalMapper, static_cast<void(QSignalMapper::*)(QObject *)>(&QSignalMapper::mapped), [=](QObject *object){ /* ... */ });
See also setMapping().
QObject *QSignalMapper::mapping(int id) const
Returns the sender QObject that is associated with the id.
See also setMapping().
QObject *QSignalMapper::mapping(const QString &id) const
This function overloads mapping().
QObject *QSignalMapper::mapping(QWidget *widget) const
This function overloads mapping().
Returns the sender QObject that is associated with the widget.
QObject *QSignalMapper::mapping(QObject *object) const
This function overloads mapping().
Returns the sender QObject that is associated with the object.
void QSignalMapper::removeMappings(QObject *sender)
Removes all mappings for sender.
This is done automatically when mapped objects are destroyed.
Note: This does not disconnect any signals. If sender is not destroyed then this will need to be done explicitly if required.
void QSignalMapper::setMapping(QObject *sender, int id)
Adds a mapping so that when map() is signalled from the given sender, the signal mapped(id) is emitted.
There may be at most one integer ID for each sender.
See also mapping().
void QSignalMapper::setMapping(QObject *sender, const QString &text)
Adds a mapping so that when map() is signalled from the sender, the signal mapped(text ) is emitted.
There may be at most one text for each sender.
void QSignalMapper::setMapping(QObject *sender, QWidget *widget)
Adds a mapping so that when map() is signalled from the sender, the signal mapped(widget ) is emitted.
There may be at most one widget for each sender.
void QSignalMapper::setMapping(QObject *sender, QObject *object)
Adds a mapping so that when map() is signalled from the sender, the signal mapped(object ) is emitted.
There may be at most one object for each sender.


Only individuals who have a NatWest account and authorised access to Online Banking should proceed beyond this point. For the security of customers, any unauthorised attempt to access customer bank information will be monitored and may be subject to legal action.


AeSys Help Index
Welcome to PegAEsys
P
rofessional
E
ngineering
G
raphics for
AE SYS
tems.
Introduction
About the Files
Features
Tutorial Drawings
Learning with Help
Commands
File menu
Edit menu
View menu
Mode menu
Tools menu
Setup menu
Window menu
Help menu


The images are sent to our servers for optimization, retrieved when they are ready and they replace the original version. While the folder is optimized, you need to keep this page open. A progress bar will be displayed and the optimized images will be shown in a compare pane below. For each folder, a .shortpixel file will be created, storing optimization metadata. You need to make sure that the folder has proper rights for the file creation/modification.
The optimization process for that folder will stop. But, if you reload the same page, or start the process over for that folder, the optimization process will continue where it left. The already optimized images will not be processed.
You can login to your ShortPixel account and check your usage statistics as well as a detailed optimization report. The default settings of the web optimizer are set to Lossy compression, remove EXIF, CMYK to RGB conversion, no WebP generation. You can find more about these settings on our blog.
Using a base URL instead of uploading files via POST significantly speeds up the optimization process as the files are downloaded in parallel by our servers instead of being uploaded via a multi-part POST message.
Press Ignore if this is a local site (not accessible from Internet) or if the access is restricted in any manner.


Here is a code body
a line in between two code blocks
Another code body with multiple lines in it that will all need to be indented


Add Permissions - Application #
Download Count: # - #
Ratings: #/5
Not a Certified Developer
User Reviews: Present
Free Application
Select Permissions:
-
Camera
-
Contacts
-
Microphone
-
Location
-
Fitness
-
Calendar
-
SMS/Message
-
Storage/Media


Members
-
<readonly> measures :Array.<TimewiseMeasure>
-
Measures in a system.
Type:
- Array.<TimewiseMeasure>
-
next :SystemLayout
-
Next system.
Type:
-
prev :SystemLayout
-
Previous system.
Type:
Measures in a system.
Next system.
Previous system.


deskShell.appDir
Folder application is running from. Works if you are running inside a package or not.
deskShell.appfs
NodeJS FS style module for accessing files served from the package if running from a package.
If you are running outside of a package this will be a standard fs module.


STRFTIME
Section: Linux Programmer's Manual (3)
Updated: 2014-08-19
Index
Return to Main Contents
NAME
strftime - format date and time
SYNOPSIS
#include <time.h>
size_t strftime(char *s, size_t max, const char *format,
const struct tm *tm);
DESCRIPTION
The
strftime()
function formats the broken-down time
tm
according to the format specification
format
and places the
result in the character array
s
of size
max.
The format specification is a null-terminated string and may contain
special character sequences called
conversion specifications,
each of which is introduced by a '%' character and terminated by
some other character known as a
conversion specifier character.
All other character sequences are
ordinary character sequences.
The characters of ordinary character sequences (including the null byte)
are copied verbatim from
format
to
s.
However, the characters
of conversion specifications are replaced as follows:
- %a
-
The abbreviated name of the day of the week according to the current locale.
- %A
-
The full name of the day of the week according to the current locale.
- %b
-
The abbreviated month name according to the current locale.
- %B
-
The full month name according to the current locale.
- %c
-
The preferred date and time representation for the current locale.
- %C
-
The century number (year/100) as a 2-digit integer. (SU)
- %d
-
The day of the month as a decimal number (range 01 to 31).
- %D
-
Equivalent to
%m/%d/%y.
(Yecch---for Americans only.
Americans should note that in other countries
%d/%m/%y
is rather common.
This means that in international context this format is
ambiguous and should not be used.) (SU)
- %e
-
Like
%d,
the day of the month as a decimal number, but a leading
zero is replaced by a space. (SU)
- %E
-
Modifier: use alternative format, see below. (SU)
- %F
-
Equivalent to
%Y-%m-%d
(the ISO 8601 date format). (C99)
- %G
-
The ISO 8601 week-based year (see NOTES) with century as a decimal number.
The 4-digit year corresponding to the ISO week number (see
%V).
This has the same format and value as
%Y,
except that if the ISO week number belongs to the previous or next year,
that year is used instead. (TZ)
- %g
-
Like
%G,
but without century, that is, with a 2-digit year (00-99). (TZ)
- %h
-
Equivalent to
%b.
(SU)
- %H
-
The hour as a decimal number using a 24-hour clock (range 00 to 23).
- %I
-
The hour as a decimal number using a 12-hour clock (range 01 to 12).
- %j
-
The day of the year as a decimal number (range 001 to 366).
- %k
-
The hour (24-hour clock) as a decimal number (range 0 to 23);
single digits are preceded by a blank.
(See also
%H.)
(TZ)
- %l
-
The hour (12-hour clock) as a decimal number (range 1 to 12);
single digits are preceded by a blank.
(See also
%I.)
(TZ)
- %m
-
The month as a decimal number (range 01 to 12).
- %M
-
The minute as a decimal number (range 00 to 59).
- %n
-
A newline character. (SU)
- %O
-
Modifier: use alternative format, see below. (SU)
- %p
-
Either "AM" or "PM" according to the given time value, or the
corresponding strings for the current locale.
Noon is treated as "PM" and midnight as "AM".
- %P
-
Like
%p
but in lowercase: "am" or "pm" or a corresponding
string for the current locale. (GNU)
- %r
-
The time in a.m. or p.m. notation.
In the POSIX locale this is equivalent to
%I:%M:%S %p.
(SU)
- %R
-
The time in 24-hour notation
(%H:%M).
(SU)
For a version including the seconds, see
%T
below.
- %s
-
The number of seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC). (TZ)
- %S
-
The second as a decimal number (range 00 to 60).
(The range is up to 60 to allow for occasional leap seconds.)
- %t
-
A tab character. (SU)
- %T
-
The time in 24-hour notation
(%H:%M:%S).
(SU)
- %u
-
The day of the week as a decimal, range 1 to 7, Monday being 1.
See also
%w.
(SU)
- %U
-
The week number of the current year as a decimal number,
range 00 to 53, starting with the first Sunday as the first day
of week 01.
See also
%V
and
%W.
- %V
-
The ISO 8601 week number (see NOTES) of the current year as a decimal number,
range 01 to 53, where week 1 is the first week that has at least
4 days in the new year.
See also
%U
and
%W.
(SU)
- %w
-
The day of the week as a decimal, range 0 to 6, Sunday being 0.
See also
%u.
- %W
-
The week number of the current year as a decimal number,
range 00 to 53, starting with the first Monday as the first day of week 01.
- %x
-
The preferred date representation for the current locale without the time.
- %X
-
The preferred time representation for the current locale without the date.
- %y
-
The year as a decimal number without a century (range 00 to 99).
- %Y
-
The year as a decimal number including the century.
- %z
-
The
+hhmm
or
-hhmm
numeric timezone (that is, the hour and minute offset from UTC). (SU)
- %Z
-
The timezone name or abbreviation.
- %+
-
The date and time in
date(1)
format. (TZ)
(Not supported in glibc2.)
- %%
-
A literal '%' character.
Some conversion specifications can be modified by preceding the
conversion specifier character by the
E
or
O
modifier
to indicate that an alternative format should be used.
If the alternative format or specification does not exist for
the current locale, the behavior will be as if the unmodified
conversion specification were used. (SU)
The Single UNIX Specification mentions
%Ec,
%EC,
%Ex,
%EX,
%Ey,
%EY,
%Od,
%Oe,
%OH,
%OI,
%Om,
%OM,
%OS,
%Ou,
%OU,
%OV,
%Ow,
%OW,
%Oy,
where the effect of the
O
modifier is to use
alternative numeric symbols (say, roman numerals), and that of the
E modifier is to use a locale-dependent alternative representation.
The broken-down time structure
tm
is defined in
<time.h>.
See also
ctime(3).
RETURN VALUE
Provided that the result string,
including the terminating null byte, does not exceed
max
bytes,
strftime()
returns the number of bytes (excluding the terminating null byte)
placed in the array
s.
If the length of the result string (including the terminating null byte)
would exceed
max
bytes, then
strftime()
returns 0, and the contents of the array are undefined.
Note that the return value 0 does not necessarily indicate an error.
For example, in many locales
%p
yields an empty string.
An empty
format
string will likewise yield an empty string.
ENVIRONMENT
The environment variables
TZ
and
LC_TIME
are used.
CONFORMING TO
SVr4, C89, C99.
There are strict inclusions between the set of conversions
given in ANSI C (unmarked), those given in the Single UNIX Specification
(marked SU), those given in Olson's timezone package (marked TZ),
and those given in glibc (marked GNU), except that
%+
is not supported in glibc2.
On the other hand glibc2 has several more extensions.
POSIX.1 only refers to ANSI C; POSIX.2 describes under
date(1)
several extensions that could apply to
strftime()
as well.
The
%F
conversion is in C99 and POSIX.1-2001.
In SUSv2, the
%S
specifier allowed a range of 00 to 61,
to allow for the theoretical possibility of a minute that
included a double leap second
(there never has been such a minute).
NOTES
ISO 8601 week dates
%G,
%g,
and
%V
yield values calculated from the week-based year defined by the
ISO 8601 standard.
In this system, weeks start on a Monday, and are numbered from 01,
for the first week, up to 52 or 53, for the last week.
Week 1 is the first week where four or more days fall within the
new year (or, synonymously, week 01 is:
the first week of the year that contains a Thursday;
or, the week that has 4 January in it).
When three of fewer days of the first calendar week of the new year fall
within that year,
then the ISO 8601 week-based system counts those days as part of week 53
of the preceding year.
For example, 1 January 2010 is a Friday,
meaning that just three days of that calendar week fall in 2010.
Thus, the ISO 8601 week-based system considers these days to be part of
week 53
(%V)
of the year 2009
(%G);
week 01 of ISO 8601 year 2010 starts on Monday, 4 January 2010.
Glibc notes
Glibc provides some extensions for conversion specifications.
(These extensions are not specified in POSIX.1-2001, but a few other
systems provide similar features.)
Between the '%' character and the conversion specifier character,
an optional
flag
and field
width
may be specified.
(These precede the
E
or
O
modifiers, if present.)
The following flag characters are permitted:
- _
-
(underscore)
Pad a numeric result string with spaces.
- -
-
(dash)
Do not pad a numeric result string.
- 0
-
Pad a numeric result string with zeros even if the conversion
specifier character uses space-padding by default.
- ^
-
Convert alphabetic characters in result string to uppercase.
- #
-
Swap the case of the result string.
(This flag works only with certain conversion specifier characters,
and of these, it is only really useful with
%Z.)
An optional decimal width specifier may follow the (possibly absent) flag.
If the natural size of the field is smaller than this width,
then the result string is padded (on the left) to the specified width.
BUGS
If the output string would exceed
max
bytes,
errno
is
not
set.
This makes it impossible to distinguish this error case from cases where the
format
string legitimately produces a zero-length output string.
POSIX.1-2001
does
not
specify any
errno
settings for
strftime().
Some buggy versions of
gcc(1)
complain about the use of
%c:
warning: `%c' yields only last 2 digits of year in some locales.
Of course programmers are encouraged to use
%c,
it gives the preferred date and time representation.
One meets all kinds of strange obfuscations
to circumvent this
gcc(1)
problem.
A relatively clean one is to add an
intermediate function
size_t
my_strftime(char *s, size_t max, const char *fmt,
const struct tm *tm)
{
return strftime(s, max, fmt, tm);
}
Nowadays,
gcc(1)
provides the
-Wno-format-y2k
option to prevent the warning,
so that the above workaround is no longer required.
EXAMPLE
RFC 2822-compliant date format
(with an English locale for %a and %b)
"%a, %d %b %Y %T %z"
RFC 822-compliant date format
(with an English locale for %a and %b)
"%a, %d %b %y %T %z"
Example program
The program below can be used to experiment with
strftime().
Some examples of the result string produced by the glibc implementation of
strftime()
are as follows:
$ ./a.out '%m'
Result string is "11"
$ ./a.out '%5m'
Result string is "00011"
$ ./a.out '%_5m'
Result string is " 11"
Program source
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
int
main(int argc, char *argv[])
{
char outstr[200];
time_t t;
struct tm *tmp;
t = time(NULL);
tmp = localtime(&t);
if (tmp == NULL) {
perror("localtime");
exit(EXIT_FAILURE);
}
if (strftime(outstr, sizeof(outstr), argv[1], tmp) == 0) {
fprintf(stderr, "strftime returned 0");
exit(EXIT_FAILURE);
}
printf("Result string is \"%s\"\n", outstr);
exit(EXIT_SUCCESS);
}
SEE ALSO
date(1),
time(2),
ctime(3),
setlocale(3),
sprintf(3),
strptime(3)
Index
- NAME
-
- SYNOPSIS
-
- DESCRIPTION
-
- RETURN VALUE
-
- ENVIRONMENT
-
- CONFORMING TO
-
- NOTES
-
- ISO 8601 week dates
-
- Glibc notes
-
- BUGS
-
- EXAMPLE
-
- Example program
-
- Program source
-
- SEE ALSO
-
This document was created by
man2html,
using the manual pages.
Time: 02:54:56 GMT, September 18, 2014


Mind Space
Use headphones for better experience
OK
Mind Space
An auditory letter writing experience
Send
Thank you for your message


The Packet Processing Graph¶
At the core of the FD.io VPP design is the Packet Procerssing Graph
This makes the software:
Pluggable, easy to understand & extend
Mature graph node architecture
Full control to reorganize the pipeline
Fast, plugins are equal citizens
The FD.io VPP packet processing pipeline is decomposed into a ‘packet processing graph’. This modular approach means that anyone can ‘plugin’ new graph nodes. This makes VPP easily extensible and means that plugins can be customized for specific purposes. VPP is also configurable through it’s Low-Level API.
At runtime, the FD.io VPP platform assembles a vector of packets from RX rings, typically up to 256 packets in a single vector. The packet processing graph is then applied, node by node (including plugins) to the entire packet vector. The received packets typically traverse the packet processing graph nodes in the vector, when the network processing represented by each graph node is applied to each packet in turn. Graph nodes are small and modular, and loosely coupled. This makes it easy to introduce new graph nodes and rewire existing graph nodes.
Plugins are shared libraries and are loaded at runtime by VPP. VPP find plugins by searching the plugin path for libraries, and then dynamically loads each one in turn on startup. A plugin can introduce new graph nodes or rearrange the packet processing graph. You can build a plugin completely independently of the FD.io VPP source tree, which means you can treat it as an independent component.
For more on the network stack press next.


Index of /themes/bird_v1/theme/assets/ckeditor/skins/bootstrapck/scss/browser-specific
Parent Directory
gecko/
ie/
ie7/
ie8/
iequirks/
opera/


Ontology: (untitled) -- No title yet.
View: recipe.
Heading 2
List1
List2
Do
not
forget to
preheat
the
oven
.


---
layout: archive
title: Lean Prover Zulip Chat Archive
permalink: 116395maths/01942quickestwaytokilltrivialmodN.html
---
The archive URL format has changed. Please find this page at:
https://leanprover-community.github.io/archive/stream/116395-maths/topic/quickest.20way.20to.20kill.20.22trivial.20mod.20N.22.3F.html


Component Wordpress
Edit (pull request)To used Wordpress you need to upload the required recipes : Apache2, Mysql and PHP.
Definition
The Wordpress is a special component of our LAMP stack. This component will allow to take the last zip of Wordpress to be uploaded on the Apache HTTP Server to be deployed.
Used version for this tutorial : Wordpress
Properties
Wordpress properties :
| Property | Usage | Comment |
|---|---|---|
| context_path | Name of folder into the default folder of apache2 | Empty as default |
| zip_url | URL from where you download the application zip | Default : https://wordpress.org/latest.zip |
Relationship and related scripts
| Relationship | Usage | Comment |
|---|---|---|
| WordpressHostedOnApache | Use to describe that the Wordpress is deployed on the targeted Apache server | Through apt-get and unzip |
| WordpressConnectToMysql | Use to describe the connection between Wordpress and Mysql | Set the conf of Mysql into config files of Wordpress |
| WordpressConnectToPHP | Use to describe the connection between Wordpress and PHP | Install the PHP module for Apache2 |
When you define a topology, make sure to select a WordpressHostedOn relation between Wordpress and Apache.