NOT HUMAN'S GALLERY
This is our gallery, displaying hundreds of our latest, finest and most spectacular artworks that we have been working on. Please enjoy it.
Feeling chill yet ? Just grab a drink.
Learn moreFeeling chill yet ? Just grab a drink.
Learn moreSome quick example text to build on the card title and make up the bulk of the card's content.
Go somewhereSome quick example text to build on the card title and make up the bulk of the card's content.
Go somewhereSome quick example text to build on the card title and make up the bulk of the card's content.
Go somewhere


Venice hit by third exceptional tide in less than a week
Venetians have endured another exceptional tide in a season that is setting records.
Other parts of Italy wrestled with weather woes on Sunday, from rain-swollen rivers to high winds and an out-of-season avalanche.
Shops and museums in Venice were mostly closed in the hardest-hit area around St Mark’s Square but tourists donning high rubber boots or even hip waders still came to witness and photograph the spectacle.
Most were disappointed when officials closed down the historic square as winds rippled across the rising waters.
The doors of St Mark’s Basilica were securely shut to the public, while officials took precautions such as stacking sandbags in canal-side windows to prevent water from entering the crypt again.
Venice’s Tide Office said the peak tide of 1.5 metres (nearly 5ft) hit just after 1pm as a weather front off the coast blocked southerly winds from the Adriatic Sea from pushing the tide to the predicted level of 1.6 metres.
It marked the third time since Tuesday night’s 1.87-metre flood – the worst in 53 years – that water levels in Venice had topped 1.5 metres.
Since records began in 1872, that level had never been reached even twice in one year, let alone three times in one week.
Officials said 280 civil protection volunteers from throughout the region were deployed to assist as needed.
The flooding has raised renewed debates about the city’s Moses flood defence project, an underwater barrier system that is still not operational after more than 16 years of construction and at least 5 billion euros (£4.2 billion) of public funding.
It was supposed to be working by 2011.
Floods also hit other parts of Italy on Sunday.
In Pisa, workers sandbagged the road along the rising Arno River, which was also surging through the heart of Florence, reaching a level near the Uffizi Galleries that was described as the highest in some 20 years.
In 24 hours, 2.5 inches of rain had fallen in Florence, which was whipped by winds as high as 42 mph.
A popular Florence tourist attraction, the Boboli Gardens, was closed as a precaution while workers checked to see if the high winds might have weakened trees.
Near another Tuscan town, Cecina, 500 people were evacuated when a local river swelled to the top of its banks.
In Italy’s mountainous Alto Adige, or South Tyrol region, a mid-autumn snowstorm triggered power outages and blocked roads in several Alpine valleys.
The mayor of Val Martello, Georg Altstaetter, told state TV that an avalanche had damaged two houses but caused no injuries.
Other homes were evacuated in the town as a precaution, he said.
A windstorm overnight in the Rome area toppled scores of trees, with two falling on cars, severely injuring a motorist, authorities said.


Student - Developer - Entrepreneur!
I Have Completed Bachelor in Computer Science. Planned on Pursuing a Master in Computer Science. Recetly Done Software Engineering Internship with UPS Information Technology. Have Solid Experiences in Software Development, Multiple Technical Tools & Languages. Has a Bigger Dream Only be Fulfilled by Strong Dedication.
-Engineered the microservices to
NPT (Network Planning Tool), a smart logistics network
which applies advanced analytics, artificial intelligence,
and operational research to optimize the flow of packages
in the UPS network.
-Built UI features and generated reports for efficient delivery
of packages using Java (Spring Tools Suite IDE), AngularJS 6 (VSCode),
and SQL (SQL Server Management Studio).
-Worked in an Agile Scrum environment.
-Responsible for designing, coding, and
modifying the Berea College website using HTML, JavaScript, CSS,
and SQL.
-Maintained and tracked accessibility issues within
websites using Siteimprove Tool.
-Added user-friendly design and clear navigation for better
interaction with the users, increased traffic 15 percent.
-Responsible for putting together a
database for CFA(Community Farm Alliance), a non-profit
organization which provides a platform for farmers and landowners to communicate.
-Developing a front end GUI (Graphical User Interface)
suitable for the database using javascript, react, and PHP
to build the complete application.
-Communicate with representatives from CFA to develop the application
according to the client’s needs.
-Responsible for 30+ students to
help them clearly understand their weekly coding projects
at computer lap. Making them a better programmer and improve
their grades.
-Leading students to technological world by providing a better
understanding of technology importance.
-Provide students with knowledge about the different aspects within
the technological field and how it relates to their major.
-Provide technical assistance
to 500+ students on a weekly basis by installing,
maintaining computer operating systems with hardware
and software packages, troubleshooting a variety of
computer issues, and setting up computer security measures,
so that students can efficiently learn without having any technical
issues.
-Team with other students to create software programs for the Berea College
IT department to maintain and update campus technology Python, HTML, CSS.
-Solved 600+ customers technical
problems and complaints weekly on satisfy customer
needs, ensuring increased customer satisfaction and
company profitability.
-Resolving mobile services, software installation
issues and providing electronics devices info for
better understanding.
-Managed operations, delegated and provided customer
engagement training for 2+ cashiers.
Ready to contact me or learn more about me?
That's great! You can view my projects on GitHub and more info on LinkedIn. Give me a call or send me an email!


User Experience (UX)
Conceive and conduct user research, translating the results into sitemaps, user flows, mockups and prototypes.
Designer
with great passion for
creating fluid and intuitive
user experiences
Developer
who loves to bring your
vision to life with clean code
<floaty hair totally optional!
>
As part of my UX research and design project I redesigned this local bicycle rental company website to improve their site accessibility and increase the company's online reservation rates.
(Software: Adobe XD, Photoshop, Illustrator)
I created this design using Adobe XD. The client is a strong, opinionated feminist artist and photographer who wanted a portfolio site to showcase her work.
(Software: Adobe XD, Photoshop)
Here I was given the design comp and coded this rather attractive three-paged site using HTML5 and CSS3.
View SiteI am a freelance UX designer and web developer currently based in London, UK.
Originally a foreign languages teacher, I embarked on my designing and coding journey because of the great frustration I felt whilst browsing websites, and realised I wanted to decode what's behind the surface and understand how this crazy thing works, and how to make it better. My curiosity has fostered a real passion for UX design - things can be so much more straightforward! I believe that simplicity is the key. We are often overwhelmed by huge amounts of information we have to deal with throughout the day, every day, and have little patience for all things online that do not work as we expect them to. My biggest mission is to design and build websites that are incredibly user friendly.
I am a perfectionist and whilst it's very hard to attain such levels, I certainly strive to. Websites should look good and be functional at the same time. Why would anyone accept less?
Conceive and conduct user research, translating the results into sitemaps, user flows, mockups and prototypes.
Shape and improve the user experience through smart combination of colors, typography, space and layouts.
Build dynamic Wordpress sites, code responsive (mobile friendly) sites using HTML, CSS, basic JavaScript and jQuery.
“I was delighted with Lana’s work on my website. She researched and communicated the options quickly and clearly and completed the work within budget. I will definitely use her again.”
Jo W.
"I trusted Lana to design and develop my site, not having much idea what I required myself. Lana researched my industry and selected the information needed to make the most impact, promoting my core values and positive aspects of my business. I am very happy with the style and colours, the site is simple enough to navigate quickly and it's not overly fussy. I am a very happy customer."
Julie W.
"I have worked with Lana on a number of occasions to help with our Website and she has proved to be very responsive, understanding, and efficient. She quickly gets to the root of the problem and is able to deliver a solution in a timely manner. Fantastic!! And I can recommend her work."
Simon C.


%inherit file="../_base1col.html"/> <%def name="title()">New CSS Form %def>
this is a p class= note
I agree to the Terms of Service, Privacy, and Refund policies.


Navigate to a channel on YouTube and copy then paste the URL above Channel Feed URL
Navigate to a channel on YouTube; go to the “Playlist” tab; Then open the playlist; Copy then paste the URL above Playlist URL
Navigate to a video on YouTube and copy then paste the URL above Single Video URL


--- layout: page title: Operations (OData Version 2.0) date: 2014-02-28 03:32:08.000000000 +08:00 permalink: /documentation/odata-version-2-0/operations/ ---
The OData protocol exposes a uniform service interface to operate on collections of structured and unstructured data. Most of the semantics of operations in OData come from the AtomPub protocol [RFC5023], which in turn builds on top of HTTP [RFC2616].
This document describes the operation model for the protocol, specifying the interactions between clients and servers for retrieving and manipulating data in an OData service. It builds on the [OData-Core] document for core concepts, [OData-URI] for URI conventions and on the formats specifications for Atom [OData-Atom] and JSON [OData-JSON] for the description of data representations.
OData supports two formats for representing resources, the XML-based Atom format and the JSON format. As described in the HTTP specification [RFC2616], clients can indicate their preference of resource representation by including an accept request header with a list of MIME types it can handle.
A client that wants only JSON responses would set this header to "application/json". For example:
GET /OData/OData.svc/Products HTTP/1.1 host: services.odata.org accept: application/json
For the Atom format there is more than one MIME type involved. Atom feeds and Entries use a content type of "application/atom+xml". However, when addressing Links or properties within an element the returned resource is just XML without the Atom Entry wrapper, and its content type is "application/xml". AtomPub also introduces service documents, with a content-type of "application/atomsvc+xml". Clients can choose to support only specific content-types or all of them. To indicate it can handle all of them a client would set the accept header to "application/atom+xml, application/atomsvc+xml, application/xml". For example:
GET /OData/OData.svc/Products HTTP/1.1 host: services.odata.org
accept: application/atom+xml,application/atomsvc+xml,application/xml
Servers are expected to honor the client request for a format or fail with status code 406 (Not Acceptable). While HTTP 1.1 allows servers to return alternate representations when none of the requested ones are available, OData servers should return one of the requested representations or fail.
If a request does not have an accept header servers should default to the Atom representation.
Since in certain scenarios it is not possible for clients to control request headers, OData also has an optional query string option called $format that can be used to override the value of the request header (e.g. $format=json or $format=atom). This option is further described in [OData-URI].
When sending a resource as part of a request or a response body, clients and servers should set the corresponding MIME type in the content-type header.
OData heavily builds on HTTP for its interaction model. In addition to content-type negotiation clients and servers should use HTTP mechanisms for aspects such as character set negotiation (through accept-charset and content-type headers), caching and redirection.
Similarly, while this specification uses specific status codes for specific outcomes for a request, clients should be prepared to handle all HTTP status codes and interpret them appropriately.
Error conditions are in general exposed as HTTP responses with error status codes (4xx and 5xx). Individual descriptions of operations in this specification do not call out error conditions. Servers should map error conditions to HTTP status codes. Common examples include using 404 (Not Found) when receiving requests against a URI not defined by this server, 400 for a general error in the request and 500 for a server-side error while processing the request.
Clients should be prepared to handle HTTP error codes in all requests.
In addition to the status code, servers should include a response body for error responses that includes more information about the error condition. The level of detail and nature of the information should be appropriate for the level of exposure of the service so as not to expose sensitive information to untrusted clients. The format for error messages is described in [OData-Atom] and [OData-JSON].
In order to provide a safe mechanism for evolution of the protocol OData has a versioning scheme. While OData is designed such that it can operate to certain extent without the use of version headers, clients and servers are strongly encouraged to follow the protocol versioning scheme. Details of OData versioning are covered in [OData-Core].
All the examples in this document assume clients and servers that use version 2.0 of the protocol.
The OData service interface has a fixed number of operations that have uniform meaning across all the resources it can act on. These operations are retrieve, create, update and delete and they map to the GET, POST, PUT/MERGE and DELETE HTTP methods. Each of them acts on a resource that is indicated using a URI. In addition to the uniform interface operations, OData allows servers to expose custom operations (known as Service Operations) that can be invoked through GET or POST.
Clients retrieve a feed, Entry or service document by issuing an HTTP GET request against its URI. Servers respond with the feed, Entry or service document in the response body in the proper format. For example, to request the feed of products in the Atom-based format from an example product catalog OData service and its corresponding response:
Request:
GET /OData/OData.svc/Products HTTP/1.1 Host: services.odata.org
accept: application/atom+xml,application/xml
DataServiceVersion: 1.0 MaxDataServiceVersion: 2.0
Response:
HTTP/1.1 200 OK Content-Length: 5685 Date: Sat, 27 Feb 2010 20:03:28 GMT Content-Type:
application/atom+xml;charset=utf-8 DataServiceVersion: 1.0;
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<feed xml:base="https://services.odata.org/OData/OData.svc
xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"
xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
xmlns="http://www.w3.org/2005/Atom">
<title type="text">Products</title>
<id>https://services.odata.org/OData/OData.svc/Products</id>
<updated>2010-02-27T20:03:28Z</updated>
<Link rel="self" title="Products" href="Products" />
<Entry> ... </Entry>
<Entry> ... </Entry>
<Entry> ... </Entry>
</feed>
To obtain a JSON response a client would issue the same request with a different accept header:
Request:
GET /OData/OData.svc/Products HTTP/1.1 Host: services.odata.org accept: application/json
DataServiceVersion: 1.0 MaxDataServiceVersion: 2.0
Response:
HTTP/1.1 200 OK Content-Length: 2481 Date: Sat, 27 Feb 2010 20:08:33 GMT Content-Type:
application/json;charset=utf-8 DataServiceVersion: 1.0; { "d" : [ { ... }, { ...
}, { ... }, ] }
When a Collection is too large to be returned in a single response, servers can return a partial list of entries as defined in AtomPub. A feed for a partial list contains subset of the entries of the Collection and a link to the next (potentially partial) list. For example:
Request:
GET /Northwind/Northwind.svc/Customers HTTP/1.1 Host: services.odata.org accept:
application/atom+xml,application/xml DataServiceVersion: 1.0 MaxDataServiceVersion:
2.0
Response:
HTTP/1.1 200 OK Content-Length: 28735 Date: Fri, 12 Mar 2010 18:05:49 GMT Content-Type:
application/atom+xml;charset=utf-8 DataServiceVersion: 2.0;
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<feed xml:base="https://services.odata.org/Northwind/Northwind.svc/"
xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"
xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
xmlns="http://www.w3.org/2005/Atom">
<title type="text">Customers</title>
<id>https://services.odata.org/Northwind/Northwind.svc/Customers</id>
<updated>2010-03-12T18:05:49Z</updated>
<link rel="self" title="Customers" href="Customers" />
<entry> ... </entry>
<entry> ... </entry>
<entry> ... </entry>
<link rel="next"
href="https://services.odata.org/Northwind/Northwind.svc/Customers?$skiptoken='ERNSH'"
/>
</feed>
There are no expectations about stability of the data across requests while traversing partial lists. Clients should be prepared to deal with missing or repeating entries.
While in many cases clients will directly follow links provided externally or found in a service document to find and retrieve a feed for a Collection, often a client will want to further control how the feed is returned. OData provide a series of optional conventions to allow clients to filter, sort and page over data in Collections, we well as to request for a subset of the properties to be sent and to expand related entries inline. All these options are discussed in [OData-URI]. An example on this would be (before escaping the URL):
https://services.odata.org/OData/OData.svc/Products?$filter=Rating gt 2&$orderby=Price&$select=Rating,Price
this requests all products with a Rating greater than 2, sorted by Price in ascending order, and asks the server to only retrieve the Rating and Price properties.
Servers may support retrieval of individual properties within Entries. OData provides two ways of exposing individual properties, one that follows OData formats and another one that exposes the raw value of the property.
When using the optional OData URL conventions, the former has an address that follows the containing Entry with the property name (e.g. Products(1)/Description to obtain the value of the "Description" property), and the latter uses a $value suffix (e.g. Products(1)/Description/$value). More details in the Resource Path section of the [OData-URI] document.
To retrieve a property value using one of the OData formats a client issues an HTTP request against the property URI, and uses content-type negotiation to indicate the expected format. Since sub-Entry elements such as properties aren't represented as whole Atom Entries, clients that use the Atom format should use "application/xml" as the content type and should be prepared to handle an XML response that is not an Atom feed or Entry. This is described in further detail in [OData-Atom]. An example of a request to retrieve the "Description" property in a Product resource follows.
Request:
GET /OData/OData.svc/Products(1)/Description HTTP/1.1 Host: services.odata.org
accept: application/xml DataServiceVersion: 1.0 MaxDataServiceVersion: 2.0
Response:
HTTP/1.1 200 OK Content-Length: 158 Date: Sat, 27 Feb 2010 21:10:15 GMT Content-Type:
application/xml;charset=utf-8 DataServiceVersion: 1.0;
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Description xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices">
Low fat milk
</Description>
To retrieve a property value in raw form a client issues an HTTP GET request against the property's raw value URL. Typically these values have a fixed content-type and negotiation is not supported (although servers are allowed to introduce this capability). Clients not having out of band knowledge of expected content-types should use "*/*" in their accept header (or not include an accept header in the request). For example:
Request:
GET /OData/OData.svc/Products(1)/Description/$value HTTP/1.1 Host: services.odata.org
DataServiceVersion: 1.0 MaxDataServiceVersion: 2.0
Response:
HTTP/1.1 200 OK Content-Length: 12 Date: Sat, 27 Feb 2010 21:16:05 GMT Content-Type:
text/plain;charset=utf-8 DataServiceVersion: 1.0; Low fat milk
Servers may expose a metadata document that describes the structure of the service and its resources. Conventionally this document is located at the /$metadata address relative to the service root URI of the service. OData metadata documents are discussed in [OData-Core].
Clients can obtain the metadata document by issuing an HTTP GET request against the metadata URI. Since only an XML serialization of EDM schemas exist currently, no content-type negotiation is supported for this resource. Other HTTP aspects such as caching and character set encoding still apply.
Following the AtomPub protocol, new Entries are created by executing an HTTP POST request against the URI of the Collection where the Entry is to be created. The POST request includes the new Entry in its body, in one of the supported formats. For example:
POST /OData/OData.svc/Categories HTTP/1.1 Host: services.odata.org
DataServiceVersion: 1.0 MaxDataServiceVersion: 2.0 accept: application/atom+xml
content-type: application/atom+xml Content-Length: 634
<?xml version="1.0" encoding="utf-8"?>
<Entry xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"
xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
xmlns="http://www.w3.org/2005/Atom">
<title type="text"></title>
<updated>2010-02-27T21:36:47Z</updated>
<author>
<name />
</author>
<category term="DataServiceProviderDemo.Category"
scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />
<content type="application/xml">
<m:properties>
<d:ID>10</d:ID>
<d:Name>Clothing</d:Name>
</m:properties>
</content>
</Entry>
Note that the client indicates both the content-type of the request body and the accept header to indicate the format of the response body, if any.
The server processes the request by creating the resource, assigning default values to all the properties not indicated in the request that are optional, and sending the final state of the resource back to the client in the response, including a "location" header that contains the URL of the Entry that was created. HTTP status code 201 reflects that the Entry has been created. For example:
HTTP/1.1 201 Created Content-Length: 1072 Date: Sat, 27 Feb 2010 21:39:54 GMT
Location: https://services.odata.org/OData/OData.svc/Categories(10) Content-Type:
application/atom+xml;charset=utf-8 DataServiceVersion: 1.0;
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Entry xml:base="https://services.odata.org/OData/OData.svc/"
xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"
xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
xmlns="http://www.w3.org/2005/Atom">
<id>https://services.odata.org/OData/OData.svc/Categories(10)</id>
<title type="text"></title>
<updated>2010-02-27T21:39:54Z</updated>
<author>
<name />
</author>
<Link rel="edit" title="Category" href="Categories(10)" />
<Link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Products"
type="application/atom+xml;type=feed" title="Products"
href="Categories(10)/Products"/>
<category term="DataServiceProviderDemo.Category"
scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme"/>
<content type="application/xml">
<m:properties>
<d:ID m:type="Edm.Int32">10</d:ID>
<d:Name>Clothing</d:Name>
</m:properties>
</content>
</Entry>
The Entry being created may contain Links to other Entries in the service. If that is the case the server is expected to create the Entry and the appropriate Links. For example, to create a new product in the catalog that is associated with the category Entry created above a client would execute a POST request against the OData.svc/Products collection with a product Entry (similar to the Category Entry above, with the proper adjustments for type information and property names and values) containing a Link to the Category Entry using any URI that resolves to that resource:
<Link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Category"
type="application/atom+xml;type=Entry" title="Category" href="Categories(10)" />
or the equivalent in JSON format as described in the Representing Links section of [OData-JSON].
Alternatively a client can create and Link an Entry to a related Entry by leveraging the addressing scheme if the server supports addressing related items. For example, if a server implements the OData URI conventions described in [OData-URI], the address …/Categories(10)/Products points at all the products in the specified category. When a POST request is issued against that products collection (instead of the top-level products collection) the server will create the new product Entry and automatically Link it to the parent category. Clients may combine this method and the previous one to create an Entry that is related to another one implicitly through the relationship implied in the URL, and related to other Entries by explicitly-specified Links in the request body.
When a client needs to create multiple related Entries it can do so as independent operations or -if the Links between Entries allow it structurally- they can perform a single POST with a tree of Entries. The tree is formed by using inline expansion as described in [OData-Atom] and [OData-JSON]. All expanded Entries are considered new. Servers process a request with inline Entries by creating individual Entries and then Linking them in the same way Linking would have happened in an independent request. This example creates the same product category Entry as before, but also creates two products in it. While this example shows an inline feed with multiple Entries, single Entries without a wrapping feed are also allowed when the cardinality of the relationship represented by the Link allows it.

As described in AtomPub, servers should create both the MR and the MLE during the execution of the POST request, and return the URI of the MLE in the Location response header.
OData servers usually initialize the structured data in the MLE by using server-generated values and information extracted from the MR. The MLE can optionally be included in the response body to update client state with server-generated information. Servers may return 201 (Created) or 200 (OK) when the MLE and MR were successfully created and a response body is returned, or 204 (No Content) if creation is successful but no response is returned.
Use of the slug header as defined in AtomPub, section 9.7 is supported and has no further semantics than those defined in that specification.
To update the data in an Entry clients execute an HTTP PUT request against the Entry's URI, with a new Entry resource included in the request body.
According to the AtomPub protocol specification, the PUT request replaces the existing Entry, so all property values in the Entry either take the values indicated in the request body, or are reset to their default value if not mentioned in the request. For example, to update a product in the sample OData service:
Request:
PUT /OData/OData.svc/Products(1) HTTP/1.1 Host: services.odata.org DataServiceVersion:
1.0 MaxDataServiceVersion: 2.0 accept: application/atom+xml
content-type: application/atom+xml Content-Length: 1181
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Entry xml:base="https://services.odata.org/OData/OData.svc/"
xmlns:d=" http://schemas.microsoft.com/ado/2007/08/dataservices"
xmlns:m=" http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
xmlns="http://www.w3.org/2005/Atom">
<id>https://services.odata.org/OData/OData.svc/Products(1)</id>
<title type="text"></title>
<updated>2010-02-28T10:23:02Z</updated>
<author>
<name />
</author>
<Link rel="edit" title="Product" href="Products(1)" />
<category term="DataServiceProviderDemo.Product"
scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />
<content type="application/xml">
<m:properties>
<d:ID m:type="Edm.Int32">1</d:ID>
<d:Name>Milk</d:Name>
<d:Description>Low fat milk</d:Description>
<d:ReleaseDate m:type="Edm.DateTime">1995-10-21T00:00:00</d:ReleaseDate>
<d:DiscontinuedDate m:type="Edm.DateTime" m:null="true" />
<d:Rating m:type="Edm.Int32">4</d:Rating>
<d:Price m:type="Edm.Decimal">4.5</d:Price>
</m:properties>
</content>
</Entry>
Response:
HTTP/1.1 204 No Content Date: Sun, 28 Feb 2010 11:32:26 GMT DataServiceVersion: 1.0;
When processing a PUT request servers return status 204 (No Content) to indicate success, no response body is needed.
In certain cases it is desirable to perform an incremental update without replacing all the contents of an Entry. In order to avoid overloading the meaning of PUT, OData uses the custom HTTP method MERGE for this scenario. A MERGE request updates only the properties indicated in the request body, and leaves untouched anything not mentioned in its current state. For example, to only update the price and rating of a product:
MERGE /OData/OData.svc/Products(1) HTTP/1.1 Host: services.odata.org
DataServiceVersion: 1.0 MaxDataServiceVersion: 2.0
accept: application/atom+xml content-type: application/atom+xml Content-Length: 1181
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Entry xml:base="https://services.odata.org/OData/OData.svc/"
xmlns:d=" http://schemas.microsoft.com/ado/2007/08/dataservices"
xmlns:m=" http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
xmlns="http://www.w3.org/2005/Atom">
<id>https://services.odata.org/OData/OData.svc/Products(1)</id>
<title type="text"></title>
<updated>2010-02-28T10:23:02Z</updated>
<author>
<name />
</author>
<Link rel="edit" title="Product" href="Products(1)" />
<category
term="DataServiceProviderDemo.Product"
scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />
<content type="application/xml">
<m:properties>
<d:Rating m:type="Edm.Int32">4</d:Rating>
<d:Price m:type="Edm.Decimal">4.5</d:Price>
</m:properties>
</content>
</Entry>
While there is a distinction between PUT and MERGE for properties, the Links of an Entry are not directly considered part of the structured data portion of an Entry and thus are not reset on PUT. Servers should use MERGE semantics for Links for both PUT and MERGE requests.
NOTE: there is active discussion in the community about the introduction of a PATCH method in HTTP. Once PATCH is an official part of the HTTP specification OData will support PATCH and phase out the custom MERGE method over time.
It is also possible to update individual properties using the same addresses a client can use to retrieve them. Clients may use the PUT method to update the value of a property. Similarly for the retrieve case, clients can choose to use URIs that point to the property in its OData format or in raw form.
For example, to update only the rating of a product:
PUT /OData/OData.svc/Products(1)/Rating HTTP/1.1 Host: services.odata.org DataServiceVersion:
1.0 MaxDataServiceVersion: 2.0 accept: application/xml
content-type: application/xml Content-Length: 275
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<d:Rating xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"
xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
m:type="Edm.Int32">5
</d:Rating>
Alternatively clients can use the address of the raw value of a property and send data in its native form. The example below shows updating the same "Rating" property, although more natural scenarios would include updating an image or an HTML document with a newer version without the need to encode it:
PUT /OData/OData.svc/Products(1)/Rating/$value HTTP/1.1 Host: services.odata.org
DataServiceVersion: 1.0 MaxDataServiceVersion: 2.0 accept: application/xml
content-type: text/plain Content-Length: 1 5
In either case servers should update the property and return 204 (No Content) and no response body or 200 (OK) and an update of the property as appropriate.
Since properties are considered atomic elements (no sub-property operations exist) the MERGE method is not defined for individual properties and servers should fail requests with this method with status code 405 (Method Not Allowed).
Entries are deleted by executing an HTTP DELETE request against a URI that points at the Entry. If the operation executed successfully servers should return 200 (OK) with no response body.
If the Entry has dependent Entries such as Entries Linked to it, it is up to the server whether deletion should be cascaded, the operation should fail because of the presence of dependent Entries, or if Links are left dangling after the Entry is deleted. This largely depends on the server, storage model and the actual application the OData service is a part of.
In the case of Media Link Entries, deleting the Media Link Entry also deletes the Media Resource.
OData provides two ways to manipulate Links: through Link constructs in Entries and by operating on the Link resources directly.
While manipulating Links by updating the Entries at either end can be simpler, this mechanism is less expressive and it is sometimes required to use Link addresses directly. For example, to add or remove a Link between two existing Entries where the Link has a cardinality of "many" on both ends (modeling a many-to-many relationship) requires the use of operations on Links directly.
A new Link between two Entries can be established by referencing one Entry during creation or modification of another Entry (as described in Creating new Entries and Updating Entries ) or by explicitly issuing a POST request against the URL of the Link resource. The request must have the new URI in the request body following the appropriate format for stand-alone Links in XML or JSON as described in [OData-Atom] and [OData-JSON].
Servers acknowledge the creation of the Link by returning a status code of 204 (No Content) and no response body. For example, to add a Link to an existing product to the list of products (through the "products" Link) of a given product category:
Request:
POST /OData/OData.svc/Categories(1)/$links/Products HTTP/1.1 Host: services.odata.org
DataServiceVersion: 1.0 MaxDataServiceVersion: 2.0 Content-Length: 159
Content-Type:application/xml
<uri xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices">
https://services.odata.org/OData/OData.svc/Products(10)
</uri>
Response:
HTTP/1.1 204 No Content Date: Tue, 02 Mar 2010 08:59:32 GMT DataServiceVersion: 1.0;
If using the OData URI conventions described in [OData-URI], the Link resource address can be derived by using the convention; otherwise it needs to be obtained from the Entry itself.
Adding a Link using POST may result in only the new Link being added or it may have further side-effects. In particular, if the other end of the Link has a cardinality of 1, then the server may remove a previously existing Link (if any) in order to create this one and still satisfy the cardinality constrain.
Existing Links may be removed by executing a DELETE request against the Link URI. Servers respond with the success status code of 204 (No Content) and no response body. For example, to delete the Link between a product and it's containing product category:
Request:
DELETE /OData/OData.svc/Categories(1)/$links/Products(10) HTTP/1.1 Host: services.odata.org
Content-Length: 0
Response:
HTTP/1.1 204 No Content Date: Tue, 02 Mar 2010 09:09:02 GMT DataServiceVersion: 1.0;
Removing Links may cause further side-effects on the server. For example servers may cascade the deletion to the Entry or Entries the Link pointed to.
Besides regular failures due to request correctness or permissions, the server may fail a DELETE request against a Link if deleting the Link would put the service data set in an inconsistent state (i.e. a state that is not allowed by the service schema).
Clients may replace a Link with a new Link by issuing an HTTP PUT request against the Link resource URI, with the new URI in the request body following the appropriate format for stand-alone Links in XML or JSON as described in [OData-Atom] and [OData-JSON]. Servers should update the Link if the service constraints allow it and return 204 (No Content). For example, to move a product from the product category with key "1" to the category with key "2":
Request:
PUT /OData/OData.svc/Products(1)/$links/Category HTTP/1.1 Host: services.odata.org
DataServiceVersion: 1.0 MaxDataServiceVersion: 2.0
accept: application/xml content-type: application/xml Content-Length: 158
<uri xmlns="http://schemas.microsoft.com/ado/2007/08/dataservices">
https://services.odata.org/OData/OData.svc/Categories(2)
</uri>
Response:
HTTP/1.1 204 No Content Date: Tue, 02 Mar 2010 19:54:52 GMT DataServiceVersion: 1.0;
Note that when updating the end of a Link that has a cardinality of 1 it is also possible to perform the operation through the Entry itself. For example, to switch back the product of the previous example to its original category:
Request:
MERGE /OData/OData.svc/Products(1) HTTP/1.1 Host: services.odata.org
DataServiceVersion: 1.0 MaxDataServiceVersion: 2.0
content-type: application/atom+xml Content-Length:590
<entry xml:base="https://services.odata.org/OData/OData.svc/"
xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"
xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
xmlns="http://www.w3.org/2005/Atom">
<Link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Category"
type="application/atom+xml;type=Entry" title="Category" href="Categories(1)" />
<category term="DataServiceProviderDemo.Product"
scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />
</entry>
Response:
HTTP/1.1 204 No Content Date: Tue, 02 Mar 2010 20:06:12 GMT DataServiceVersion: 1.0;
Since this is a merge operation and no actual properties are mentioned, the server should only update the Links included in the request body.
Service Operations expose custom behaviors that do not map to the uniform interface. Service operations can be defined to take parameters, which are simple scalar values of one of the EDM primitive types as defined in [OData-Core].
Clients may invoke a Service Operation by issuing an HTTP GET or POST request against their URI. If a particular Service Operation takes parameters they should be included as part of the query string in the request URI as described in the Addressing Service Operations section of [OData-URI]. The name of each parameter is used as the name of the query string parameter, and its value should be in OData literal form. No "$" prefix should be used in parameters ("$" is reserved for OData parameters). For example:
Request:
GET /odata/odata.svc/GetProductsByRating?rating=4 HTTP/1.1 Host: services.odata.org
DataServiceVersion: 1.0 MaxDataServiceVersion: 2.0
Response:
HTTP/1.1 200 OK Content-Length: 1957 Date: Tue, 02 Mar 2010 20:59:21 GMT
Content-Type: application/atom+xml;charset=utf-8 DataServiceVersion: 1.0;
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<feed
xml:base="https://services.odata.org/(S(dwaygaylwritgwuiyvfad5ln))/OData/OData.svc/"
xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"
xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
xmlns="http://www.w3.org/2005/Atom">
<title type="text">GetProductsByRating</title>
<id>
https://services.odata.org/(S(dwaygaylwritgwuiyvfad5ln))/odata/odata.svc/GetProductsByRating
</id>
<updated>2010-03-02T20:59:21Z</updated>
<Link rel="self" title="GetProductsByRating" href="GetProductsByRating" />
<Entry> ... </Entry>
</feed>
Server implementations should only allow invocation of Service Operations through GET when the operations will not cause side-effects in the system.
Service authors can choose to enable query composition in Service Operations if the operation returns a Collection of Entries. When that is the case, clients may use the URI conventions defined in [OData-URI] treating the URI to the Service Operation as the URI to the initial collection, and then applying the convention from there.
OData uses HTTP ETags for optimistic concurrency control. A few special considerations apply for ETags:
OData servers will use weak ETags often as a way of indicating that two resources may be semantically equivalent but a particular request may see a different representation of it. Clients should be prepared to handle weak and strong ETags.
In many scenarios clients are limited to the HTTP GET and POST methods only. In order to help work-around this limitation, OData servers can support method tunneling through POST. The methods that can be executed through tunneling are MERGE, PUT and DELETE.
To issue a request with method tunneling a client sets up a request with body and headers as needed, but uses POST as the HTTP method instead of the actual required one. It then adds one more header, "X-HTTP-Method", and gives it the value MERGE, PUT or DELETE.
Servers must check if POST requests have the X-HTTP-Method header set to one of the valid values and if so execute the rest of the request as if the header value was the actual HTTP method for it.
As discussed in [OData-Core] the OData data model supports open types for Entries. An entry of an open type may have extra properties (dynamic properties) in addition to those statically declared in metadata.
In general servers should treat dynamic properties and static properties as uniformly as possible.
For data retrieval servers should include dynamic and static properties in entries and should use the same format for both, as discussed in [OData-Atom] and [OData-JSON].
From the query semantics perspective dynamic and static properties apply equally in all contexts (projection, filter, sorting, etc.). Similarly in the addressing scheme dynamic and static properties should be handled in the same way (e.g. it is legal to address a dynamic property within an entry in servers that support the URI convention discussed in [OData-URI]). Dynamic properties may not be present in all entries within a collection; query processors should treat missing properties as if they had a null value.
During update processing, dynamic properties should be appended to entries when they appear on a POST, PUT or MERGE request. They can also be incrementally added to existing entries using a MERGE operation with the dynamic properties to be added. A PUT request resets all the properties not mentioned in the request to their default values, and removes all the dynamic properties that may have been previously added to this entry but were not mentioned in this request. When a dynamic property is explicitly mentioned in a POST/PUT/MERGE request and has a null value, the server may choose to preserve its existence as a null dynamic property or remove it from the entry, as the rest of the system should behave as if it was there but had a null value already.


This is a hybrid mobile app developed using Ionic Creator.
Ionic Creator is the IDE for Ionic and provides drag-and-drop GUI building and integrated AngularJS scripting.
https://creator.ionic.io
Ionic is a hybrid mobile app framework based on Cordova and AngularJS.
Single code base. Deploy to any device.
https://ionicframework.com/


| All the indexes are organised in a tree. As an example, here are some parts of the tree created by the BeBook add-on, on the left.
All the elements of the tree are called HappyLinks. Each HappyLink has a name, a link to an html file, and a few other things I'll describe later. The first HappyLink of the list has the name of the documentation, and points to its main html file (usually index.html). This link has some children (here 'By Kit', 'By Inheritance', 'Functions Index' and 'Topics Index'), and each child will be interpreted as an index for BeHappy (ie they will be in the popup menu). They also point on the main html file. The grandchildren (such as the different kits) and their offspring will be put in the lists BeHappy displays under the popup menu. |


This model calculates medium properties for an ideal gas of a single substance, or for an ideal gas consisting of several substances where the mass fractions are fixed. Independent variables are temperature T and pressure p. Only density is a function of T and p. All other quantities are solely a function of T. The properties are valid in the range:
200 K ≤ T ≤ 6000 K
The following quantities are always computed:
| Variable | Unit | Description |
| h | J/kg | specific enthalpy h = h(T) |
| u | J/kg | specific internal energy u = u(T) |
| d | kg/m^3 | density d = d(p,T) |
For the other variables, see the functions in Modelica.Media.IdealGases.Common.SingleGasNasa. Note, dynamic viscosity and thermal conductivity are only provided for gases that use a data record from Modelica.Media.IdealGases.FluidData. Currently these are the following gases:
Ar C2H2_vinylidene C2H4 C2H5OH C2H6 C3H6_propylene C3H7OH C3H8 C4H8_1_butene C4H9OH C4H10_n_butane C5H10_1_pentene C5H12_n_pentane C6H6 C6H12_1_hexene C6H14_n_heptane C7H14_1_heptene C8H10_ethylbenz CH3OH CH4 CL2 CO CO2 F2 H2 H2O He N2 N2O NH3 NO O2 SO2 SO3
Sources for model and literature:
Original Data: Computer program for calculation of complex chemical
equilibrium compositions and applications. Part 1: Analysis
Document ID:<PHONE_NUMBER>4 N (95N20180) File Series: NASA Technical
Reports Report Number: NASA-RP-1311 E-8017 NAS 1.61:1311 Authors:
Gordon, Sanford (NASA Lewis Research Center) Mcbride, Bonnie J.
(NASA Lewis Research Center) Published: Oct 01, 1994.
Known limits of validity:
The data is valid for temperatures between 200K and 6000K. A few of
the data sets for monatomic gases have a discontinuous 1st
derivative at 1000K, but this never caused problems so far.
This model has been copied from the ThermoFluid library and adapted to the Modelica.Media package.
| Name | Description |
|---|---|
| ThermodynamicState | Thermodynamic state variables for ideal gases |
| BaseProperties | Base properties of ideal gas medium |
| setState_pTX | Return thermodynamic state as function of p, T and composition X |
| setState_phX | Return thermodynamic state as function of p, h and composition X |
| setState_psX | Return thermodynamic state as function of p, s and composition X |
| setState_dTX | Return thermodynamic state as function of d, T and composition X |
| setSmoothState | Return thermodynamic state so that it smoothly approximates: if x > 0 then state_a else state_b |
| pressure | Return pressure of ideal gas |
| temperature | Return temperature of ideal gas |
| density | Return density of ideal gas |
| specificEnthalpy | Return specific enthalpy |
| specificInternalEnergy | Return specific internal energy |
| specificEntropy | Return specific entropy |
| specificGibbsEnergy | Return specific Gibbs energy |
| specificHelmholtzEnergy | Return specific Helmholtz energy |
| specificHeatCapacityCp | Return specific heat capacity at constant pressure |
| specificHeatCapacityCv | Compute specific heat capacity at constant volume from temperature and gas data |
| isentropicExponent | Return isentropic exponent |
| velocityOfSound | Return velocity of sound |
| isentropicEnthalpyApproximation | Approximate method of calculating h_is from upstream properties and downstream pressure |
| isentropicEnthalpy | Return isentropic enthalpy |
| isobaricExpansionCoefficient | Returns overall the isobaric expansion coefficient beta |
| isothermalCompressibility | Returns overall the isothermal compressibility factor |
| density_derp_T | Returns the partial derivative of density with respect to pressure at constant temperature |
| density_derT_p | Returns the partial derivative of density with respect to temperature at constant pressure |
| density_derX | Returns the partial derivative of density with respect to mass fractions at constant pressure and temperature |
| dynamicViscosity | Dynamic viscosity |
| thermalConductivity | Thermal conductivity of gas |
| molarMass | Return the molar mass of the medium |
| T_h | Compute temperature from specific enthalpy |
| T_ps | Compute temperature from pressure and specific entropy |
| dynamicViscosityLowPressure | Dynamic viscosity of low pressure gases |
| thermalConductivityEstimate | Thermal conductivity of polyatomic gases(Eucken and Modified Eucken correlation) |


MTV Poland mistakes NCT 127 for BTS at MTV EMA's 2019
by Sach007NCT127 are currently in Seville attending the MTV EMA's 2019. They are also performing at the award show. The MTV Poland mistook them for BTS at the red carpet. They tagged BTS's instagram handle with NCT127 picture from the red carpet on their official instagram story.
Checkout the screenshot from their instagram story below.


--- layout: default title: 主页 lang: zh_CN identifier: home --- {% include portal-language-switcher.html %} {% for post in site.collections %}


Name That
MathWorker
Find this person:
You win! Play again?
Prompt with names
Prompt with faces
Number of Clicks:
0
Time:
0
Correct:
0


Declaration :
Artifact : CalendarData
Relation cd (<unidirectional association>) |
Declaration :
Stereotype: List
Operation CalendarData |
Declaration :
Operation getEvents |
Gets every event in the calendar.
@return events
Declaration :
Operation getEventsBetween |
Gets any event(s) in the calendar between two times.
@param from lower bound
@param to upper bound
@return events between lower and upper bounds
Declaration :
All public operations : getEvents , getEventsBetween , getTimestamp , getTimestamp


Satellite List
Here is the list of the satellite names recognized by @WheresThatSat. The list is periodically synchronized with the set of current two-line element sets available from CelesTrak, and as such may change as additions or deletions are made to the CelesTrak catalog.
Aliases
Many satellite names are terse or abbreviated. The following aliases are defined to help @WheresThatSat recognize alternate or expanded forms of certain satellite names. Please send feedback if you have suggestions for additional aliases.
Names
Name recognition is not case-sensitive. Additionally, spaces and hyphens are interchangeable.


Investment Calculator
Amount invested (principal):
Annual rate (example: 0.06):
Number of years:
Periods per year:
Compute future value


 Be careful not to use a system operator name, because this command may change its definition. The operator being declared must have at least two arguments, and the second one must be a kernel.
operator f; linear f; f(0,x); 0 f(-y,x); - F(1,X)*Y f(y+z,x); F(1,X)*(Y + Z) f(y*z,x); F(1,X)*Y*Z depend z,x; f(y*z,x); F(Z,X)*Y f(y/z,x); 1 F(-,X)*Y Z depend y,x; f(y/z,x); Y F(-,X) Z nodepend z,x; f(y/z,x); F(Y,X) ------ Z f(2*e**sin(x),x); SIN(X) 2*F(E ,X)
Even when the operator has not had its functionality attached, it exhibits linear properties as shown in the examples. Notice the difference when dependencies are added. Dependencies are also in effect when the operator's first argument contains its second, as in the last line above.
For a fully-developed example of the use of linear operators, refer to the article in the <Journal of Computational Physics>, Vol. 14 (1974), pp. 301-317, ``Analytic Computation of Some Integrals in Fourth Order Quantum Electrodynamics," by J.A. Fox and A.C. Hearn. The article includes the complete listing of REDUCE procedures used for this work.
 Default is 80.
linelength<expression>
To change the linelength, <expression> must evaluate to a positive integer less than 128 (although this varies from system to system), and should not be less than 20 or so for proper operation.
linelengthreturns the previous linelength. If you want the current linelength value, but not change it, say linelength nil.
 When lisp is followed by an expression, that expression is evaluated in symbolic mode, but REDUCE's mode is not changed. This command is equivalent to symbolic.
lisp; NIL car '(a b c d e); A algebraic; c := (lisp car '(first second))**2; 2 C := FIRSTINDEX
LISTARGP _ _ _ _ _ _ _ _ _ _ _ _ declaration
If an operator other than those specifically defined for lists is given a single argument that is a list, then the result of this operation will be a list in which that operator is applied to each element of the list. This process can be inhibited for a specific operator, or list of operators, by using the declaration listargp.
log {a,b,c}; LOG(A),LOG(B),LOG(C) listargp log; log {a,b,c}; LOG(A,B,C)
It is possible to inhibit such distribution globally by turning on the switch listargs. In addition, if an operator has mor e than one argument, no such distribution occurs, so listargp has no effect.
INDEX
NODEPEND _ _ _ _ _ _ _ _ _ _ _ _ declaration
The nodepend declaration removes the dependency declared with depend.
nodepend<dep-kernel>{,<kernel>}+
<dep-kernel> must be a kernel that has had a dependency declared upon the one or more other kernels that are its other arguments.
depend y,x,z; df(sin y,x); COS(Y)*DF(Y,X) df(sin y,x,z); COS(Y)*DF(Y,X,Z) - DF(Y,X)*DF(Y,Z)*SIN(Y) nodepend y,z; df(sin y,x); COS(Y)*DF(Y,X) df(sin y,x,z); 0
A warning message is printed if the dependency had not been declar ed by depend.
INDEX
MATCH _ _ _ _ _ _ _ _ _ _ _ _ command
The match command is similar to the let command, except that it matches only explicit powers in substitution.
match<expr> = <expression>{,<expr> =<expression>}*
<expr> is generally a term involving powers, and is limited by the rules for the let command. <expression> may be any valid REDUCE scalar expression.
match c**2*a**2 = d; (a+c)**4; 4 3 3 4 A + 4*A *C + 4*A*C + C + 6*D match a+b = c; a + 2*b; B + C (a + b + c)**2; 2 2 2 A - B + 2*B*C + 3*C clear a+b; (a + b + c)**2; 2 2 2 A + 2*A*B + 2*A*C + B + 2*B*C + C let p*r = s; match p*q = ss; (a + p*r)**2; 2 2 A + 2*A*S + S (a + p*q)**2; 2 2 2 A + 2*A*SS + P *Q
Note in the last example that a + b has been explicitly m atched after the squaring was done, replacing each single power of a by c - b. This kind of substitution, although following the rules, is confusing and could lead to unrecognizable results. It is better to use match with explicit powers or products only. match should not be used inside procedures for the same reasons that let should not be.
Unlike let substitutions, match substitutio ns are executed after all other operations are complete. The last example shows the difference. match commands can be cleared by using clear, with exactly the expression that the original match took. match commands can also be done more generally with for all or forall...such that commands.
 The equality check is to prevent an infinite loop. The operator f can have other functionality attached to it if desired, or it can remain an indeterminate operator.
 Expressions involving an operator declared in this manner are transformed if the first argument contains a minus sign. Any other arguments are not affected.
odd f; f(-a) -F(A) f(-a,-b) -F(A,-B) f(a,-b) F(A,-B)
If say f is declared odd, then f(0) is replaced by zero unless f is also declared non zero by the declaration nonzero.
 There is no problem if the switch is already off. If the switch name is mistyped, an error message is given.
 There is no problem if the switch is already on. If the switch name is mistyped, an error message is given.
 The second operator is the factorial.
Operators can have various properties assigned to them; they can be declared infix, linear, symmetric, antisymmetric, or noncommutative. The default operator is prefix, nonlinear, and commutative. Precedence can also be assigned to operators using the declaration precedence.
Functionality is assigned to an operator by a let statement or a forall...let statement, (or possibly by a procedure with the name of the operator). Be careful not to redefine a system operator by accident. REDUCE permits you to redefine system operators, giving you a warning message that the operator was already defined. This flexibility allows you to add mathematical rules that do what you want them to do, but can produce odd or erroneous behavior if you are not careful.
You can declare operators from inside procedures, as long as they are not local variables. Operators defined inside procedures are global. A formal parameter may be declared as an operator, and has the effect of declaring the calling variable as the operator.
INDEX
ORDER _ _ _ _ _ _ _ _ _ _ _ _ declaration
The order declaration changes the order of precedence of kernels for display purposes only.
order<identifier>{,<identifier>}*
<kernel> must be a valid kernel or operator name complete with argument or a list of such objects.
x + y + z + cos(a); COS(A) + X + Y + Z order z,y,x,cos(a); x + y + z + cos(a); Z + Y + X + COS(A) (x + y)**2; 2 2 Y + 2*Y*X + X order nil; (z + cos(z))**2; 2 2 COS(Z) + 2*COS(Z)*Z + Z
orderaffects the printing order of the identifiers only; internal order is unchanged. Change internal order of evaluation with the declaration korder. You can use order to feature variables or functions you are particularly interested in.
Declarations made with order are cumulative: kernels in new order declarations are ordered behind those in previous declarations, and previous declarations retain their relative order. Of course, specific kernels named in new declarations are removed from previous ones and given the new priority. Return to the standard canonical printing order with the statement order nil.
The print order specified by order commands is not in effect if the switch pri is off.

Attaching a precedence to an operator has the side effect of declaring the operator to be infix. If the identifier argument for precedence has not been declared to be an operator, an attempt to use it causes an error message. After declaring it to be an operator, it becomes an infix operator with the precedence previously given. Infix operators may be used in prefix form; if they are used in infix form, a space must be left on each side of the operator to avoid ambiguity. Declared infix operators are always binary.
To see the infix operator precedence list, enter symbolic mode and type preclis!*;. The lowest precedence operator is listed first.
All prefix operators have precedence higher than infix operators.
 Default is system dependent, a nd normally about 12.
precision(<integer>) or precision <integer>
<integer> must be a positive integer. When <integer> is 0, the current precision is displayed, but not changed. There is no upper limit, but precision of greater than several hundred causes unpleasantly slow operation on numeric calculations.
on rounded; 7/9; 0.777777777778 precision 20; 20 7/9; 0.77777777777777777778 sin(pi/4); 0.7071067811865475244
Trailing zeroes are dropped, so sometimes fewer than 20 decimal pl aces are printed as in the last example. Turn on the switch fullprec if you want to print all significant digits. The rounded mode carries calculations to two more places than given by precision, and rounds off.
  They are initialized to zero.
real<identifier>{,<identifier>}*
<identifier> may be any valid REDUCE identifier, except t or nil.
Real variables remain local, and do not share values with variables of the same name outside the begin...end block. When the block is finished, the variables are removed. You may use the words integer or scalar in the place of real. real does not indicate typechecking by the current REDUCE; it is only for your own information. Declaration statements must immediately follow the begin, without a semicolon between begin and the first variable declaration.
Any variables used inside a begin...end block that were not declared scalar, real or integer are global, and any change made to them inside the block affects their global value. Any array or matrix declared inside a block is always global.

 Th ey are initialized to 0.
scalar<identifier>{,<identifier>}*
<identifier> may be any valid REDUCE identifier, except t or nil.
Scalar variables remain local, and do not share values with variables of the same name outside the begin...end block. When the block is finished, the variables are removed. You may use the words real or integer in the place of scalar. real and integer do not indicate typechecking by the current REDUCE; they are only for your own information. Declaration statements must immediately follow the begin, without a semicolon between begin and the first variable declaration.
Any variables used inside begin...end blocks that were not declared scalar, real or integer are global, and any change made to them inside the block affects their global value. Arrays declared inside a block are always global.
 At the default settings, any number with five or less digits before the decimal point is printed in a fixed-point notation, e.g., 12345.6. Numbers with more than five digits are printed in scientific notation, e.g., 1.234567E+5. Similarly, by default, any number with eleven or more zeros after the decimal point is printed in scientific notation.
When scientific_notation is called with the numerical argument m a number with more than m digits before the decimal point, or m or more zeros after the decimal point, is printed in scientific notation. When scientific_notation is called with a list {<m>,<n>}, a number with more than m digits before the decimal point, or n or more zeros after the decimal point is printed in scientific notation.
on rounded; 12345.6; 12345.6 123456.5; 1.234565e+5 0.00000000000000012; 1.2e-16 scientific_notation 20; 5,11 5: 123456.7; 123456.7 0.00000000000000012; 0.00000000000000012INDEX
SHARE _ _ _ _ _ _ _ _ _ _ _ _ declaration
The share declaration allows access to its arguments by both algebraic and symbolic modes.
share<identifier>{,<identifier>}*
<identifier> can be any valid REDUCE identifier.
Programming in symbolic as well as algebraic mode allows you a wider range of techniques than just algebraic mode alone. Expressions do not cross the boundary since they have different representations, unless the share declaration is used. For more information on using symbolic mode, see the <REDUCE User's Manual>, and the <Standard Lisp Report>.
You should be aware that a previously-declared array is destroyed by the share declaration. Scalar variables retain their values. You can share a declared matrix that has not yet been dimensioned so that it can be used by both modes. Values that are later put into the matrix are accessible from symbolic mode too, but not by the usual matrix reference mechanism. In symbolic mode, a matrix is stored as a list whose first element is MAT, and whose next elements are the rows of the matrix stored as lists of the individual elements. Access in symbolic mode is by the operators first, second, third and rest.
 When symbolic is followed by an expression, that expression is evaluated in symbolic mode, but REDUCE's mode is not changed. It is equivalent to the lisp command.
symbolic; NIL cdr '(a b c); (B C) algebraic; x + symbolic car '(y z); X + YINDEX
SYMMETRIC _ _ _ _ _ _ _ _ _ _ _ _ declaration
When an operator is declared symmetric, its arguments are reordered to conform to the internal ordering of the system.
symmetric<identifier>{,<identifier>}*
<identifier> is an identifier that has been declared an operator.
operator m,n; symmetric m,n; m(y,a,sin(x)); M(SIN(X),A,Y) n(z,m(b,a,q)); N(M(A,B,Q),Z)
If <identifier> has not been declared to be an operator, the flag symmetric is still attached to it. When <identifier> is subsequently used as an operator, the message Declare<identifier> operator ? (Y or N) is printed. If the user replies y, the symmetric property of the operator is used.
 It is only useful to those with a good knowledge of both Lisp and the internal formats used by REDUCE.
<name> is the name of a REDUCE system procedure or one of your own procedures.
The system procedure prepsq is traced, which prepares REDUCE standard forms for printing by converting them to a Lisp prefix form.
tr prepsq; (PREPSQ) x**2 + y; PREPSQ entry: Arg 1: (((((X . 2) . 1) ((Y . 1) . 1)) . 1) PREPSQ return value = (PLUS (EXPT X 2) Y) PREPSQ entry: Arg 1: (1 . 1) PREPSQ return value = 1 2 X + Y untr prepsq; (PREPSQ)
This example is for a PSL-based system; the above format will vary if other Lisp systems are used.
When a procedure is traced, the first lines show entry to the procedure and the arguments it is given. The value returned by the procedure is printed upon exit. If you are tracing several procedures, with a call to one of them inside the other, the inner trace will be indented showing procedure nesting. There are no trace options. However, the format of the trace depends on the underlying Lisp system used. The trace can be removed with the command untr. Note that trace, below, is a m atrix operator, while tr does procedure tracing.
 It is only useful to those with a good knowledge of both Lisp and the internal formats used by REDUCE.
<name> is the name of a REDUCE system procedure or one of your own procedures that has previously been the argument of a tr declaration.
INDEX
VARNAME _ _ _ _ _ _ _ _ _ _ _ _ declaration
The declaration varname instructs REDUCE to use its argument as the default Fortran (when fort is on) or structr identifier and identifier stem, rather than using ANS.
varname<identifier>
<identifier> can be any combination of one or more alphanumeric characters. Try to avoid REDUCE reserved words.
varname ident; IDENT on fort; x**2 + 1; IDENT=X**2+1. off fort,exp; structr(((x+y)**2 + z)**3); 3 IDENT2 where 2 IDENT2 := IDENT1 + Z IDENT1 := X + Y
expwas turned off so that structr could show the structure. If exp had been on, the expression would have been expanded into a polynomial.

Weights are originally equivalent to 0 until set by a weight command. To remove a weight from a kernel, use the clear command. Weights once assigned cannot be changed without clearing the identifier. Once a weight is assigned to a kernel, it is no longer a kernel and cannot be used in any REDUCE commands or operators that require kernels, until the weight is cleared. Note that terms are ordered by greatest weight.
The weight level of the system is set by wtlevel, initially at 2. Since no kernels have weights, no effect from wtlevel can be seen. Once you assign weights to kernels, you must set wtlevel correctly for the desired operation. When weighted variables appear in a term, their weights are summed for the total weight of the term (powers of variables multiply their weights). When a term exceeds the weight level of the system, it is discarded from the result expression.
 Alternatively a rule or a rule list can be a member of the right-hand part of a where expression.
x**2 + 17*x*y + 4*y**2 where x=1,y=2; 51 for i := 1:5 collect x**i*q where q= for j := 1:i product j; 2 3 4 5 {X,2*X ,6*X ,24*X ,120*X } x**2 + y + z where z=y**3,y=3; 2 3 X + Y + 3
Substitution inside a where expression has no effect upon the values of the kernels outside the expression. The where operator has the lowest precedence of all the infix operators, which are lower than prefix operators, so that the substitutions apply to the entire expression preceding the where operator. However, where is applied before command keywords such as then, repeat, or do.
A rule or a rule set in the right-hand part of the where expression act as if the rules were activated by let immediately before the evaluation of the expression and deactivated by clearrules immediately afterwards.
wheregives you a natural notation for auxiliary variables in expressions. As the second example shows, the substitute expression can be a command to be evaluated. The substitute assignments are made in parallel, rather than sequentially, as the last example shows. The expression resulting from the first round of substitutions is not reexamined to see if any further such substitutions can be made. where can also be used to define auxiliary variables in procedure definitions.
 If the condition is initially false, the statement is not executed at all.
while<condition> do <statement>
<condition> is given by a logical operator, <statement> must be a single REDUCE statement, or a group (<<...>>) or begin...end block.
a := 10; A := 10 while a <= 12 do <<write a; a := a + 1>>; 10 11 12 while a < 5 do <<write a; a := a + 1>>; nothing is printedINDEX
WTLEVEL _ _ _ _ _ _ _ _ _ _ _ _ command
In conjunction with weight, wtlevel is used to implement asymptotic constraints. Its default value is 2.
wtlevel<expression>
To change the weight level, <expression> must evaluate to a positive integer that is the greatest weight term to be retained in expressions involving kernels with weight assignments. wtlevel returns the new weight level. If you want the current weight level, but not change it, say wtlevel nil.
(x+y)**4; 4 3 2 2 3 4 X + 4*X *Y + 6*X *Y + 4*X*Y + Y weight x=2,y=3; wtlevel 8; (x+y)**4; 4 X wtlevel 10; (x+y)**4; 2 2 2 X *(6*Y + 4*X*Y + X ) int(x**2,x); ***** X invalid as KERNEL
wtlevelis used in conjunction with the command weight to enable asymptotic constraints. Weight of a term is computed by multiplying the weights of each variable in it by the power to which it has been raised, and adding the resulting weights for each variable. If the weight of the term is greater than wtlevel, the term is dropped from the expression, and not used in any further computation involving the expression.
Once a weight has been attached to a kernel, it is no longer recognized by the system as a kernel, though still a variable. It cannot be used in REDUCE commands and operators that need kernels. The weight attachment can be undone with a clear command. wtlevel can be changed as desired.
INDEX
Declarations
IN _ _ _ _ _ _ _ _ _ _ _ _ command
The in command takes a list of file names and inputs each file into the system.
in<filename>{,<filename>}*
<filename> must be in the current directory, or be a valid pathname. If the file name is not an identifier, double quote marks (") are needed around the file name.
A message is given if the file cannot be found, or has a mistake in it.
Ending the command with a semicolon causes the file to be echoed to the screen; ending it with a dollar sign does not echo the file. If you want some but not all of a file echoed, turn the switch echo on or off in the file.
An efficient way to develop procedures in REDUCE is to write them into a file using a system editor of your choice, and then input the files into an active REDUCE session. REDUCE reparses the procedure as it takes information from the file, overwriting the previous procedure definition. When it accepts the procedure, it echoes its name to the screen. Data can also be input to the system from files.
Files to be read in should always end in end; to avoid end-of-file problems. Note that this is an additional end; to any ending procedures in the file.

An expression brought back by input can be reexecuted with new values or switch settings, or used as an argument in another expression. The command ws brings back the results of a numbered REDU CE statement. Two lists contain every input and every output statement since the beginning of the session. If your session is very long, storage space begins to fill up with these expressions, so it is a good idea to end the session once in a while, saving needed expressions to files with the saveas and out commands.
Switch settings and let statements can also be reexecuted by usin g input.
An error message is given if a number is called for that has not yet been used.
 If the file name is not in the current directory, quote marks are needed around the file name. If the file already exists, a message is printed allowing you to decide whether to supersede the contents of the file with new material.
To restore output to the terminal, type out t, or shut the file. When you use out t, the file remains available, and if you open it again (with another out), new material is appended rather than overwriting.
To write a file using out that can be input at a later time, the switch nat must be turned off, so that the standard linear form is saved that can be read in by in. If nat is on, exponents are printed on the line above the expression, which causes trouble when REDUCE tries to read the file.
There is a slight complication if you are using the out command from inside a file to create another file. The echo switch is normally off at the top-level and on while reading files (so you can see what is being read in). If you create a file using out at the top-level, the result lines are printed into the file as you want them. But if you create such a file from inside a file, the echo switch is on, and every line is echoed, first as you typed it, then as REDUCE parsed it, and then once more for the file. Therefore, when you create a file from a file, you need to turn echo off explicitly before the out command, and turn it back on when you shut the created file, so your executing file echoes as it should. This behavior also means that as you watch the file execute, you cannot see the lines that are being put into the out file. As soon as you turn echo on, you can see output again.

A file that has been opened by out must be shut before it is brought in by in. Files that have been opened by out should always be shut before the end of the REDUCE session, to avoid either loss of information or the printing of extraneous information into the file. In most systems, terminating a session by bye closes all open output files.

 It takes an arbitrary scalar expression as its argument. The derivative of acosh is known to the system. Numerical values may also be found by turning on the switch rounded.
<expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple\_expression> must be a single identifier or begin with a prefix operator name.
acosh a; ACOSH(A) acosh(0); ACOSH(0) df(acosh(a**2),a); 4 2*SQRT(A - 1)*A ---------------- 4 A - 1 int(acosh(x),x); INT(ACOSH(X),X)
You may attach functionality by defining acosh to be the inverse of cosh. This is done by the commands
put('cosh,'inverse,'acosh); put('acosh,'inverse,'cosh);
You can write a procedure to attach integrals or other functions to acosh. You may wish to add a check to see that its argument is properly restricted.
 It takes an arbitrary scalar expression as its argument. The derivative of acot is known to the system. Numerical values may also be found by turning on the switch rounded.
<expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple\_expression> must be a single identifier or begin with a prefix operator name. You can add functionality yourself with let and procedures.
 It takes an arbitrary scalar expression as its argument. The derivative of acoth is known to the system. Numerical values may also be found by turning on the switch rounded.
<expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple\_expression> must be a single identifier or begin with a prefix operator name. You can add functionality yourself with let and procedures.

 It takes an arbitrary scalar expression as its argument. The derivative of asech is known to the system. Numerical values may also be found by turning on the switch rounded.
<expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple\_expression> must be a single identifier or begin with a prefix operator name.
asech a; ASECH(A) asech(1); 0 df(acosh(a**2),a); 4 2*SQRT(- A + 1) ---------------- 4 A*(A - 1) int(asech(x),x); INT(ASECH(X),X)
You may attach functionality by defining asech to be the inverse of sech. This is done by the commands
put('sech,'inverse,'asech); put('asech,'inverse,'sech);
You can write a procedure to attach integrals or other functions to asech. You may wish to add a check to see that its argument is properly restricted.

 The derivative of asinh and some simple transformations are known to the system.
<expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple\_expression> must be a single identifier or begin with a prefix operator name.
asinh d; ASINH(D) asinh(1); ASINH(1) df(asinh(2*x),x); 2 2*SQRT(4*X + 1)) ----------------- 2 4*X + 1
You may attach further functionality by defining asinh to be the inverse of sinh. This is done by the commands
put('sinh,'inverse,'asinh); put('asinh,'inverse,'sinh);
A numeric value is not returned by asinh unless the switch rounded is on and its argument evaluates to a number.

 The derivative of asinh and some simple transformations are known to the system.
<expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple\_expression> must be a single identifier or begin with a prefix operator name.
atanh aa; ATANH(AA) atanh(1); ATANH(1) df(atanh(x*y),y); - X ---------- 2 2 X *Y - 1
A numeric value is not returned by asinh unless the switc h rounded is on and its argument evaluates to a number. You may attach additional functionality by defining atanh to be the inverse of tanh.  In rounded mode, if a numerical value exists, atan2 returns the principal value of the arc tangent of the second argument divided by the first in the range [-pi,+pi] radians, using the signs of both arguments to determine the quadrant of the return value. An expression in terms of atan2 is returned in other cases.
atan2(3,2); ATAN2(3,2); on rounded; atan2(3,2); 0.982793723247 atan2(a,b); ATAN2(A,B); atan2(1,0); 1.57079632679
atan2returns a numeric value only if rounded is on. Then atan2 is calculated to the current degree of floating point precision.
 Then the cosine is calculated to the current degree of floating point precision.


(). transmission air SARS-CoV- spread building coronavirus viral particles COVID- health potential respiratory virus care indoor {border-style human airborne outside px;} #ffffff;} Infect humidity individuals SARS disease increase novel acute contact environment potentially surfaces viruses higher infectious reduce room syndrome .collab: However, measures occupants rooms spaces ventilation common increased infection influenza microbial number patient patients relative severe (COVID-) Control including prevent social-distancing space taken SARS-CoV-. aerosolized built contamination droplets exchange exposure filters hospital infected light outbreak pathogens px; research risk spatial {font-family Den Dis:â€". Van buildings cases control demonstrated environmental facilities, filter font-size high host known likely masks microbes new pathways social (), BE, Centers Coronavirus Diamond Disease Engl HEPA Higher MERS-CoV MERV- Med:â€". Princess University Wuhan, article critical design disinfection doi:./S-()-. doi:./s---. double; filtration help important increasing individual mediated occupant operators particles, pathogen possible preliminary range ranging survival symptoms use viruses, (half-life Atlanta, BE. BrownGZ, Furthermore, GA. Health Indoor KlineJ, LiY, Med NorthcuttD, SARS-CoV-, abiotic aerosol airflow approximately areas associated bacterial border-color border-width buildings, cause changes communities corporate corridor directly doi:./. efficiency fomites germicidal implement increases large maintenance measures. mechanisms open operational pathways. person-to-person process remove required solid; study surface systems transmitted types {font-style {font-weight (SARS-CoV-) (â€"). -nCoV Administrators Based Built California, Californiaâ€"Davis, China China, CoVs, Davis, Emerg Environ GreenJL, HVAC Hosp Institute J:â€". January Microbiol:â€". One:e. Oregon, Prevention, South UVC WongJY, abundance, administrators bold causing city clinical communities, confirmed contain coronavirus. courier; cruise current data decision-making degree designed determined direct doi:./eid.. doi:./journal.pone.. dynamics em; environmentally fractions function, future given hand identified implemented inactivation infections information maintaining medianâ€‰=â€‰. minimize mold observed operations provide pt;} rate rates recent related represent requirements routine shown simulated spectrum strategy studies sunlight transfer transmission. typical viability Âµm


Configuring Feedback Category Settings
How to configure the option category settings for the Feedback module.
Tip: One or more categories must be created prior to configuring these settings. See "Adding Feedback Categories"
-
- Select the Feedback Settings tab.
- Expand the Feedback Category Settings section.
- At Category, select the category associated with this module. This displays the selected category name on the module.
- At Category List Visible, to enable users to select an alternative category - OR - to disable category selection.
- At Category Required, if it is mandatory to select a category to submit feedback - OR - if selecting a category is optional.
- At Use Category Value as Send To, to use the category value as the email address of the recipient of this message. Where no email address exists in the category value, then the "Send To" value is used - OR - to disable.
-
Click the OK button to confirm.


Welcome to my website
There's lots to do here
Have a sneeaky look around!
Are you scared of a crocodileee?
What are your FAVOURITE things about a crocky?
Lots of teeth
Shades of green
Prickly backs
The way they lurk
See you l8r aligator
Learn how to communicate with your crocs
Email Address
How many crocs do you want?
Do you want to receive marketing communications?
Get the cats
Breed
Eats
Laziness
Stabyhoun
Chicken
1/10
Labrador
Anything
7/10


Brand Identity & Web Developer
2019
HTML, CSS, Graphic Design
Over the course of six months, I worked on a technology consulting team for Evanston Development Cooperative, an organization in Evanston which advocates for afforable housing through building accessory dwelling units (ADUs) in the Chicago area. My team built and deployed both EDC's public website and back-end tool for housing searches and price analytics. As front-end designer and graphics lead for my team, I created EDC's logo, designed EDC's website architecture, and generated a brand book and style guide for the newly conceived affordable housing cooperative.
As the graphics lead, I took on the task of designing EDC's logo. At the time, EDC was nascent and had no clearly defined brand identity. After rounds of designs and feedback from the team at EDC, we settled on the logo below. The colors reflect those of the town of Evanston, where EDC is based, and the logo loosely resembles an ADU nestled between two main houses.
Throughout this project, I also developed both a brand and style guide for EDC to record the brand's image and serve as a reference when creating future marketing materials, announcements, etc.


GDG DevFest
October 2015, Lviv
GDG DevFest 2014
•
Become a sponsor
•
Become a speaker
Contact us:
<EMAIL_ADDRESS>GDG DevFest Ukraine 2014 - Highlights